oarust 0.8.6

// @generated by tool/gen/fn/generate.py; DO NOT EDIT.
// schemas=matrix_elemwise.json,matrix_blas.json,matrix_reduce.json,matrix_rng.json,matrix_index.json,ml_training.json,audio.json,cryptography_hash.json,image.json,vision_detection.json generator_version=64
// matrix_elemwise_sha256=6d4112435554d3615e6c2494c5062e5f93fa85815bccffa2ca49b12f97aaac75
// matrix_blas_sha256=31a29676780c696e7f6a77f290398587a9e29e612903c5816503e35d3dda8687
// matrix_reduce_sha256=82fbdb597e6fd7557a8c081a6302ceb383b2df455716387a549bed1a21f44fdd
// matrix_rng_sha256=44767f064bbe8a861ee136a4b6ac710d80d5acc0febb4921a9b455dfac0147d6
// matrix_index_sha256=d8dcc521d7c0f1e349c806b97571addc859ed4779ca094dfdc7791e6fd641c5e
// ml_training_sha256=6678961ee57f24310158676c7b4fe0821e21ca48db7edcb20d2a749a164976ae
// audio_sha256=1e7b6d6f13531fd8c330038c46a9b63856ef432febbe1a6ca1bd786b0081278b
// cryptography_hash_sha256=5659414fbdf658b15d08f85afa35d5c8e610ddff7066bf4cd09f024d5accc3f7
// image_sha256=0d0c5f1db8252e02650e5d790ba1eb27975549b460917d76d9b7a0234ffb64a1
// vision_detection_sha256=c6188d1144d35167edf6c6f7034479db95afa18e51bc00b293a1022fa6e6f0c2

use std::sync::OnceLock;

use super::{
	CollisionPolicy, LogicalWriteDomain, PhysicalWrite, PhysicalWriteContract, ShaderArtifact,
	TailPolicy, WorkspacePartition, WriteExtent, WritePartition,
};

pub(crate) const MAX_BOUNDED_STORAGE_BUFFERS: u32 = 24;

static MATRIX_ADD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_add_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_ADD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_add_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static MATRIX_ADD_I32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_add_i32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_ADD_I32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_add_i32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static MATRIX_ADD_BROADCAST_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_add_broadcast_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_ADD_BROADCAST_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_add_broadcast_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static MATRIX_ADD_BROADCAST_I32_I32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_add_broadcast_i32_i32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_ADD_BROADCAST_I32_I32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_add_broadcast_i32_i32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static MATRIX_SUB_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_sub_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_SUB_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_sub_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static MATRIX_SUB_BROADCAST_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_sub_broadcast_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_SUB_BROADCAST_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_sub_broadcast_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static MATRIX_MUL_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_mul_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_MUL_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_mul_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static MATRIX_MUL_BROADCAST_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_mul_broadcast_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_MUL_BROADCAST_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_mul_broadcast_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static MATRIX_DIV_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_div_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_DIV_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_div_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static MATRIX_DIV_BROADCAST_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_div_broadcast_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_DIV_BROADCAST_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_div_broadcast_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static MATRIX_SCALE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_scale_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_SCALE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_scale_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static MATRIX_NEG_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_neg_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_NEG_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_neg_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static MATRIX_ABS_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_abs_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_ABS_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_abs_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static MATRIX_LOG_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_log_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_LOG_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_log_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static MATRIX_SQRT_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_sqrt_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_SQRT_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_sqrt_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static MATRIX_POW_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_pow_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_POW_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_pow_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static MATRIX_ADD_SCALAR_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_add_scalar_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_ADD_SCALAR_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_add_scalar_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static MATRIX_SUB_SCALAR_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_sub_scalar_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_SUB_SCALAR_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_sub_scalar_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static MATRIX_DIV_SCALAR_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_div_scalar_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_DIV_SCALAR_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_div_scalar_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static MATRIX_EXP_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_exp_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_EXP_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_exp_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static MATRIX_SIN_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_sin_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_SIN_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_sin_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static MATRIX_COS_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_cos_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_COS_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_cos_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static MATRIX_RECIPROCAL_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_reciprocal_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_RECIPROCAL_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_reciprocal_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static MATRIX_CLAMP_MAX_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_clamp_max_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_CLAMP_MAX_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_clamp_max_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static MATRIX_CLAMP_MIN_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_clamp_min_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_CLAMP_MIN_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_clamp_min_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static MATRIX_COPY_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_copy_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_COPY_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_copy_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static MATRIX_COPY_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_copy_u8.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_COPY_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_copy_u8_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static MATRIX_COPY_I32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_copy_i32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_COPY_I32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_copy_i32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static MATRIX_COPY_U32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_copy_u32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_COPY_U32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_copy_u32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static MATRIX_MAT_MUL_NT_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_mat_mul_nt_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [64, 64, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_MAT_MUL_NT_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_mat_mul_nt_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [64, 64, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static MATRIX_SOFTMAX_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_softmax_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::AxisSlices,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::AxisSlice,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_SOFTMAX_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_softmax_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::AxisSlices,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::AxisSlice,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static MATRIX_SOFTMAX_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_softmax_backward_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::AxisSlices,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::AxisSlice,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_SOFTMAX_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_softmax_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::AxisSlices,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::AxisSlice,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static MATRIX_LOG_SOFTMAX_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_log_softmax_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::AxisSlices,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::AxisSlice,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_LOG_SOFTMAX_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_log_softmax_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::AxisSlices,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::AxisSlice,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static MATRIX_LOG_SOFTMAX_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_log_softmax_backward_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::AxisSlices,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::AxisSlice,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_LOG_SOFTMAX_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_log_softmax_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::AxisSlices,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::AxisSlice,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static MATRIX_SUM_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_sum_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::Scalar,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::OneScalar,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_SUM_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_sum_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::Scalar,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::OneScalar,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static MATRIX_SUM_AXIS_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_sum_axis_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_SUM_AXIS_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_sum_axis_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static MATRIX_SUM_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_sum_backward_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_SUM_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_sum_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static MATRIX_CATEGORICAL_ACCURACY_COUNT_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_categorical_accuracy_count_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::Scalar,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::OneScalar,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_CATEGORICAL_ACCURACY_COUNT_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_categorical_accuracy_count_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::Scalar,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::OneScalar,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static MATRIX_MASKED_CATEGORICAL_ACCURACY_COUNT_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_masked_categorical_accuracy_count_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::Scalar,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::OneScalar,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_MASKED_CATEGORICAL_ACCURACY_COUNT_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_masked_categorical_accuracy_count_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::Scalar,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::OneScalar,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static MATRIX_PHILOX_UNIFORM_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_philox_uniform_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1024, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_PHILOX_UNIFORM_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_philox_uniform_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1024, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static MATRIX_PHILOX_NORMAL_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_philox_normal_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [512, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_PHILOX_NORMAL_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_philox_normal_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [512, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static MATRIX_PHILOX_UNIFORM_REPLAY_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_philox_uniform_replay_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1024, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_PHILOX_UNIFORM_REPLAY_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_philox_uniform_replay_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1024, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static MATRIX_PHILOX_NORMAL_REPLAY_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_philox_normal_replay_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [512, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_PHILOX_NORMAL_REPLAY_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_philox_normal_replay_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [512, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static MATRIX_PHILOX_REPLAY_ADVANCE_U32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_philox_replay_advance_u32.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_PHILOX_REPLAY_ADVANCE_U32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_philox_replay_advance_u32_bounded.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static MATRIX_DROPOUT_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_dropout_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1024, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_DROPOUT_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_dropout_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1024, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static MATRIX_DROPOUT_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_dropout_backward_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1024, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_DROPOUT_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_dropout_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1024, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static MATRIX_SAMPLE_LOGITS_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_sample_logits_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_SAMPLE_LOGITS_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_sample_logits_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static MATRIX_SAMPLE_LOGITS_DENSE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_sample_logits_dense_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_SAMPLE_LOGITS_DENSE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_sample_logits_dense_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static MATRIX_SAMPLE_LOGITS_SORTED_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_sample_logits_sorted_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_SAMPLE_LOGITS_SORTED_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_sample_logits_sorted_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static MATRIX_DROPOUT_REPLAY_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_dropout_replay_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1024, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_DROPOUT_REPLAY_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_dropout_replay_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1024, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static MATRIX_DROPOUT_BACKWARD_REPLAY_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_dropout_backward_replay_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1024, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_DROPOUT_BACKWARD_REPLAY_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_dropout_backward_replay_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1024, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static MATRIX_TOP_K_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_top_k_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 1,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 2,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_TOP_K_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_top_k_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 1,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 2,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static MATRIX_TOP_K_MASK_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_top_k_mask_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_TOP_K_MASK_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_top_k_mask_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static MATRIX_MOE_EXPERT_PLAN_U32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_moe_expert_plan_u32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 1,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 2,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_MOE_EXPERT_PLAN_U32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_moe_expert_plan_u32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 1,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 2,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static MATRIX_MOE_ROUTING_BIAS_UPDATE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_moe_routing_bias_update_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_MOE_ROUTING_BIAS_UPDATE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_moe_routing_bias_update_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static MATRIX_SLICE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_slice_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_SLICE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_slice_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static MATRIX_SLICE_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_slice_backward_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_SLICE_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_slice_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static MATRIX_REPEAT_INTERLEAVE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_repeat_interleave_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_REPEAT_INTERLEAVE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_repeat_interleave_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static MATRIX_REPEAT_INTERLEAVE_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_repeat_interleave_backward_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_REPEAT_INTERLEAVE_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_repeat_interleave_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static MATRIX_GATHER_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_gather_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_GATHER_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_gather_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static MATRIX_GATHER_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_gather_backward_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::RowWidth,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_GATHER_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_gather_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::RowWidth,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static MATRIX_GATHER_LAST_DIM_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_gather_last_dim_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_GATHER_LAST_DIM_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_gather_last_dim_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static MATRIX_GATHER_LAST_DIM_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_gather_last_dim_backward_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_GATHER_LAST_DIM_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_gather_last_dim_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static MATRIX_CONCAT_U32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_concat_u32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_CONCAT_U32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_concat_u32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static MATRIX_TRANSPOSE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_transpose_f32.spv")),
	workgroup_size: [32, 32, 1],
	dispatch_tile_size: [32, 32, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::Tile32x32,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_TRANSPOSE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/matrix_transpose_f32_bounded.spv"
	)),
	workgroup_size: [32, 32, 1],
	dispatch_tile_size: [32, 32, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::Tile32x32,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static MATRIX_EQUAL_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_equal_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_MATRIX_EQUAL_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/matrix_equal_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_PPO_CLIPPED_POLICY_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_ppo_clipped_policy_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_PPO_CLIPPED_POLICY_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_ppo_clipped_policy_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_PPO_CLIPPED_POLICY_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_ppo_clipped_policy_backward_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_PPO_CLIPPED_POLICY_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_ppo_clipped_policy_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_LINEAR_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_linear_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [64, 64, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_LINEAR_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_linear_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [64, 64, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_LINEAR_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_linear_backward_f32.spv")),
	workgroup_size: [64, 1, 1],
	dispatch_tile_size: [32, 32, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_LINEAR_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_linear_backward_f32_bounded.spv"
	)),
	workgroup_size: [64, 1, 1],
	dispatch_tile_size: [32, 32, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_LINEAR_PARAMETER_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_linear_parameter_backward_f32.spv"
	)),
	workgroup_size: [32, 8, 1],
	dispatch_tile_size: [32, 8, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_LINEAR_PARAMETER_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_linear_parameter_backward_f32_bounded.spv"
	)),
	workgroup_size: [32, 8, 1],
	dispatch_tile_size: [32, 8, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_CROSS_ENTROPY_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_cross_entropy_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_CROSS_ENTROPY_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_cross_entropy_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_CROSS_ENTROPY_SUM_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_cross_entropy_sum_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_CROSS_ENTROPY_SUM_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_cross_entropy_sum_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_CROSS_ENTROPY_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_cross_entropy_backward_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_CROSS_ENTROPY_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_cross_entropy_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_MASKED_CROSS_ENTROPY_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_masked_cross_entropy_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MASKED_CROSS_ENTROPY_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_masked_cross_entropy_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_MASKED_CROSS_ENTROPY_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_masked_cross_entropy_backward_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::RowWidth,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MASKED_CROSS_ENTROPY_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_masked_cross_entropy_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::RowWidth,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_SMOOTH_L1_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_smooth_l1_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_SMOOTH_L1_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_smooth_l1_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_SMOOTH_L1_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_smooth_l1_backward_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_SMOOTH_L1_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_smooth_l1_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_SMOOTH_L1_MEAN_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_smooth_l1_mean_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::Scalar,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::OneScalar,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_SMOOTH_L1_MEAN_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_smooth_l1_mean_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::Scalar,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::OneScalar,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_MSE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_mse_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MSE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_mse_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_MSE_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_mse_backward_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MSE_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_mse_backward_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_L1_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_l1_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_L1_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_l1_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_L1_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_l1_backward_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_L1_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_l1_backward_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_BCE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_bce_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_BCE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_bce_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_BCE_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_bce_backward_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_BCE_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_bce_backward_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_SGD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_sgd_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_SGD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_sgd_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_CLIP_GRAD_NORM_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_clip_grad_norm_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_CLIP_GRAD_NORM_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_clip_grad_norm_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_CLIP_GRAD_NORM_SCALE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_clip_grad_norm_scale_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_CLIP_GRAD_NORM_SCALE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_clip_grad_norm_scale_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_SGD_MOMENTUM_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_sgd_momentum_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_SGD_MOMENTUM_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_sgd_momentum_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_ADAM_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_adam_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_ADAM_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_adam_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_MUON_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_muon_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MUON_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_muon_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_MUON_VECTOR_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_muon_vector_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MUON_VECTOR_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_muon_vector_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_MUON_NORMALIZE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_muon_normalize_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MUON_NORMALIZE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_muon_normalize_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_MUON_MAT_MUL_AXPBY_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_muon_mat_mul_axpby_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MUON_MAT_MUL_AXPBY_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_muon_mat_mul_axpby_f32_bounded.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_MUON_LINEAR_COMBINATION_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_muon_linear_combination_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MUON_LINEAR_COMBINATION_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_muon_linear_combination_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_MUON_TRANSPOSE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_muon_transpose_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MUON_TRANSPOSE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_muon_transpose_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_MUON_APPLY_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_muon_apply_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MUON_APPLY_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_muon_apply_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_ADAMW_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_adamw_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_ADAMW_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_adamw_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_ADAMW_GRAPH_ADVANCE_U32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_adamw_graph_advance_u32.spv")),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_ADAMW_GRAPH_ADVANCE_U32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_adamw_graph_advance_u32_bounded.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_ADAMW_GRAPH_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_adamw_graph_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_ADAMW_GRAPH_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_adamw_graph_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_EMBEDDING_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_embedding_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_EMBEDDING_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_embedding_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_EMBEDDING_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_embedding_backward_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_EMBEDDING_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_embedding_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_CHANNEL_NORM_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_channel_norm_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::RowWidth,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_CHANNEL_NORM_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_channel_norm_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::RowWidth,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_CHANNEL_NORM_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_channel_norm_backward_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_CHANNEL_NORM_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_channel_norm_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_CHANNEL_NORM_RELU_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_channel_norm_relu_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::RowWidth,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_CHANNEL_NORM_RELU_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_channel_norm_relu_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::RowWidth,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_CHANNEL_NORM_RELU_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_channel_norm_relu_backward_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_CHANNEL_NORM_RELU_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_channel_norm_relu_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_EMBEDDING_U8_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_embedding_u8_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_EMBEDDING_U8_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_embedding_u8_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_EMBEDDING_BACKWARD_U8_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_embedding_backward_u8_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_EMBEDDING_BACKWARD_U8_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_embedding_backward_u8_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_RNN_SCAN_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_rnn_scan_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_RNN_SCAN_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_rnn_scan_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_RNN_SCAN_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_rnn_scan_backward_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_RNN_SCAN_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_rnn_scan_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_LAYER_NORM_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_layer_norm_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_LAYER_NORM_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_layer_norm_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_LAYER_NORM_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_layer_norm_backward_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_LAYER_NORM_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_layer_norm_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_RMS_NORM_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_rms_norm_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::RowWidth,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_RMS_NORM_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_rms_norm_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::RowWidth,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_RMS_NORM_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_rms_norm_backward_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_RMS_NORM_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_rms_norm_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_GELU_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_gelu_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_GELU_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_gelu_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_GELU_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_gelu_backward_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_GELU_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_gelu_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_SILU_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_silu_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_SILU_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_silu_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_SILU_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_silu_backward_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_SILU_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_silu_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_RELU_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_relu_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_RELU_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_relu_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_RELU_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_relu_backward_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_RELU_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_relu_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_TANH_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_tanh_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_TANH_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_tanh_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_TANH_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_tanh_backward_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_TANH_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_tanh_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_SIGMOID_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_sigmoid_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_SIGMOID_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_sigmoid_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_SIGMOID_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_sigmoid_backward_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_SIGMOID_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_sigmoid_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_LEAKY_RELU_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_leaky_relu_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_LEAKY_RELU_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_leaky_relu_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_LEAKY_RELU_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_leaky_relu_backward_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_LEAKY_RELU_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_leaky_relu_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_ELU_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_elu_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_ELU_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_elu_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_ELU_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_elu_backward_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_ELU_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_elu_backward_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_MISH_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_mish_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MISH_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_mish_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_MISH_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_mish_backward_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MISH_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mish_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_SOFTPLUS_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_softplus_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_SOFTPLUS_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_softplus_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_SOFTPLUS_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_softplus_backward_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_SOFTPLUS_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_softplus_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_QKV_PROJECTION_BIAS_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_qkv_projection_bias_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_QKV_PROJECTION_BIAS_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_qkv_projection_bias_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_SWIGLU_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_swiglu_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_SWIGLU_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_swiglu_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_SWIGLU_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_swiglu_backward_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_SWIGLU_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_swiglu_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_GATE_UP_SWIGLU_BIAS_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_gate_up_swiglu_bias_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_GATE_UP_SWIGLU_BIAS_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_gate_up_swiglu_bias_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_ADAMW_MANY4_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_adamw_many4_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_ADAMW_MANY4_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_adamw_many4_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_ADAMW_MANY4_GRAPH_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_adamw_many4_graph_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_ADAMW_MANY4_GRAPH_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_adamw_many4_graph_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_ROPE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_rope_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_ROPE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_rope_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_ROPE_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_rope_backward_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_ROPE_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_rope_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_AVG_POOL_2D_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_avg_pool_2d_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_AVG_POOL_2D_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_avg_pool_2d_f32_bounded.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_AVG_POOL_2D_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_avg_pool_2d_backward_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_AVG_POOL_2D_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_avg_pool_2d_backward_f32_bounded.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_MAX_POOL_2D_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_max_pool_2d_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 1,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 2,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MAX_POOL_2D_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_max_pool_2d_f32_bounded.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 1,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 2,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_MAX_POOL_2D_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_max_pool_2d_backward_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MAX_POOL_2D_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_max_pool_2d_backward_f32_bounded.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_ADAPTIVE_AVG_POOL_2D_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_adaptive_avg_pool_2d_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_ADAPTIVE_AVG_POOL_2D_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_adaptive_avg_pool_2d_f32_bounded.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_ADAPTIVE_AVG_POOL_2D_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_adaptive_avg_pool_2d_backward_f32.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_ADAPTIVE_AVG_POOL_2D_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_adaptive_avg_pool_2d_backward_f32_bounded.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_BATCH_NORM_2D_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_batch_norm_2d_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 1,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 2,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_BATCH_NORM_2D_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_batch_norm_2d_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 1,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 2,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_BATCH_NORM_2D_WITH_STATS_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_batch_norm_2d_with_stats_f32.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 5,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_BATCH_NORM_2D_WITH_STATS_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_batch_norm_2d_with_stats_f32_bounded.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 5,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_BATCH_NORM_2D_RUNNING_UPDATE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_batch_norm_2d_running_update_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_BATCH_NORM_2D_RUNNING_UPDATE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_batch_norm_2d_running_update_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_BATCH_NORM_2D_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_batch_norm_2d_backward_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_BATCH_NORM_2D_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_batch_norm_2d_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_BATCH_NORM_2D_INPUT_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_batch_norm_2d_input_backward_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_ML_BATCH_NORM_2D_INPUT_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_batch_norm_2d_input_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static ML_UPSAMPLE_2D_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_upsample_2d_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_UPSAMPLE_2D_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_upsample_2d_f32_bounded.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_UPSAMPLE_2D_BILINEAR_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_upsample_2d_bilinear_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_UPSAMPLE_2D_BILINEAR_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_upsample_2d_bilinear_f32_bounded.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_UPSAMPLE_2D_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_upsample_2d_backward_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_UPSAMPLE_2D_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_upsample_2d_backward_f32_bounded.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_UPSAMPLE_2D_BILINEAR_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_upsample_2d_bilinear_backward_f32.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_UPSAMPLE_2D_BILINEAR_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_upsample_2d_bilinear_backward_f32_bounded.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_CONV_2D_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_conv_2d_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_CONV_2D_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_conv_2d_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_CONV_2D_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_conv_2d_backward_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_CONV_2D_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_conv_2d_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_CONV_2D_PARAMETER_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_conv_2d_parameter_backward_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 2,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_CONV_2D_PARAMETER_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_conv_2d_parameter_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 2,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_CONV_1D_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_conv_1d_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_CONV_1D_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_conv_1d_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_CONV_1D_BIAS_ADD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_conv_1d_bias_add_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 0,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_CONV_1D_BIAS_ADD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_conv_1d_bias_add_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 0,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_CONV_1D_TRANSPOSE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_conv_1d_transpose_f32.spv")),
	workgroup_size: [32, 32, 1],
	dispatch_tile_size: [32, 32, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_CONV_1D_TRANSPOSE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_conv_1d_transpose_f32_bounded.spv"
	)),
	workgroup_size: [32, 32, 1],
	dispatch_tile_size: [32, 32, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_CONV_1D_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_conv_1d_backward_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_CONV_1D_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_conv_1d_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_CONV_1D_PARAMETER_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_conv_1d_parameter_backward_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 2,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_CONV_1D_PARAMETER_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_conv_1d_parameter_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 2,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_CONV_TRANSPOSE_1D_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_conv_transpose_1d_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_CONV_TRANSPOSE_1D_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_conv_transpose_1d_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_CONV_TRANSPOSE_1D_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_conv_transpose_1d_backward_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_CONV_TRANSPOSE_1D_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_conv_transpose_1d_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_CONV_TRANSPOSE_2D_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_conv_transpose_2d_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_CONV_TRANSPOSE_2D_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_conv_transpose_2d_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_CONV_TRANSPOSE_2D_BIAS_ADD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_conv_transpose_2d_bias_add_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 0,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_CONV_TRANSPOSE_2D_BIAS_ADD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_conv_transpose_2d_bias_add_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 0,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_CONV_TRANSPOSE_2D_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_conv_transpose_2d_backward_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_CONV_TRANSPOSE_2D_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_conv_transpose_2d_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_CONV_TRANSPOSE_2D_PARAMETER_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_conv_transpose_2d_parameter_backward_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 2,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_CONV_TRANSPOSE_2D_PARAMETER_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_conv_transpose_2d_parameter_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 2,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_GRU_SCAN_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_gru_scan_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_GRU_SCAN_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_gru_scan_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_GRU_SCAN_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_gru_scan_backward_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_GRU_SCAN_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_gru_scan_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_GRU_CELL_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_gru_cell_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_GRU_CELL_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_gru_cell_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_GRU_CELL_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_gru_cell_backward_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::UpToFourElements,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::UpToFourElements,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_GRU_CELL_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_gru_cell_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::UpToFourElements,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::UpToFourElements,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_RNN_CELL_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_rnn_cell_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_RNN_CELL_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_rnn_cell_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_RNN_CELL_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_rnn_cell_backward_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_RNN_CELL_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_rnn_cell_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_BMM_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_bmm_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_BMM_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_bmm_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_BMM_TILED_16_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_bmm_tiled_16_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::Tile16x16,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_BMM_TILED_16_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_bmm_tiled_16_f32_bounded.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::Tile16x16,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_BMM_NT_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_bmm_nt_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_BMM_NT_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_bmm_nt_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_BMM_NT_TILED_16_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_bmm_nt_tiled_16_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::Tile16x16,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_BMM_NT_TILED_16_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_bmm_nt_tiled_16_f32_bounded.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::Tile16x16,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_BMM_TN_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_bmm_tn_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_BMM_TN_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_bmm_tn_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_BMM_TN_TILED_16_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_bmm_tn_tiled_16_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::Tile16x16,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_BMM_TN_TILED_16_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_bmm_tn_tiled_16_f32_bounded.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::Tile16x16,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_SPLIT_HEADS_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_split_heads_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_SPLIT_HEADS_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_split_heads_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_MERGE_HEADS_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_merge_heads_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MERGE_HEADS_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_merge_heads_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_SOFTMAX_SCALED_MASKED_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_softmax_scaled_masked_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::RowWidth,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_SOFTMAX_SCALED_MASKED_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_softmax_scaled_masked_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::RowWidth,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_SOFTMAX_SCALED_MASKED_N32_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_softmax_scaled_masked_n32_f32.spv"
	)),
	workgroup_size: [32, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::RowWidth,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_SOFTMAX_SCALED_MASKED_N32_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_softmax_scaled_masked_n32_f32_bounded.spv"
	)),
	workgroup_size: [32, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::RowWidth,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_SOFTMAX_SCALED_MASKED_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_softmax_scaled_masked_backward_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::RowWidth,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_SOFTMAX_SCALED_MASKED_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_softmax_scaled_masked_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::RowWidth,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_SCALED_DOT_PRODUCT_ATTENTION_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_scaled_dot_product_attention_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::RowWidth,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_SCALED_DOT_PRODUCT_ATTENTION_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_scaled_dot_product_attention_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::RowWidth,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_SDPA_SOFTMAX_N32_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_sdpa_softmax_n32_f32.spv")),
	workgroup_size: [32, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::RowWidth,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_SDPA_SOFTMAX_N32_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_sdpa_softmax_n32_f32_bounded.spv"
	)),
	workgroup_size: [32, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::RowWidth,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_FLASH_ATTENTION_CAUSAL_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_flash_attention_causal_f32.spv"
	)),
	workgroup_size: [64, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_FLASH_ATTENTION_CAUSAL_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_flash_attention_causal_f32_bounded.spv"
	)),
	workgroup_size: [64, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_SCALED_DOT_PRODUCT_ATTENTION_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_scaled_dot_product_attention_backward_f32.spv"
	)),
	workgroup_size: [64, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 6,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::RowWidth,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_SCALED_DOT_PRODUCT_ATTENTION_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_scaled_dot_product_attention_backward_f32_bounded.spv"
	)),
	workgroup_size: [64, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 6,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::RowWidth,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_FLASH_ATTENTION_CAUSAL_BACKWARD_KV_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_flash_attention_causal_backward_kv_f32.spv"
	)),
	workgroup_size: [64, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 7,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_FLASH_ATTENTION_CAUSAL_BACKWARD_KV_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_flash_attention_causal_backward_kv_f32_bounded.spv"
	)),
	workgroup_size: [64, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 7,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_MOE_ROUTE_WEIGHTS_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_moe_route_weights_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::RowWidth,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MOE_ROUTE_WEIGHTS_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_moe_route_weights_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::RowWidth,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_MOE_ROUTE_WEIGHTS_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_moe_route_weights_backward_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 4,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MOE_ROUTE_WEIGHTS_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_moe_route_weights_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 4,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_MOE_GATHER_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_moe_gather_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MOE_GATHER_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_moe_gather_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_MOE_GATHER_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_moe_gather_backward_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MOE_GATHER_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_moe_gather_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_MOE_COMBINE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_moe_combine_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MOE_COMBINE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_moe_combine_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_MOE_COMBINE_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_moe_combine_backward_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MOE_COMBINE_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_moe_combine_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_GROUPED_LINEAR_M_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_grouped_linear_m_f32.spv")),
	workgroup_size: [64, 1, 1],
	dispatch_tile_size: [32, 32, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 4,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_GROUPED_LINEAR_M_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_grouped_linear_m_f32_bounded.spv"
	)),
	workgroup_size: [64, 1, 1],
	dispatch_tile_size: [32, 32, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 4,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_GROUPED_LINEAR_M_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_grouped_linear_m_backward_f32.spv"
	)),
	workgroup_size: [64, 1, 1],
	dispatch_tile_size: [32, 32, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_GROUPED_LINEAR_M_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_grouped_linear_m_backward_f32_bounded.spv"
	)),
	workgroup_size: [64, 1, 1],
	dispatch_tile_size: [32, 32, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_GROUPED_LINEAR_M_PARAMETER_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_grouped_linear_m_parameter_backward_f32.spv"
	)),
	workgroup_size: [64, 1, 1],
	dispatch_tile_size: [32, 32, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_GROUPED_LINEAR_M_PARAMETER_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_grouped_linear_m_parameter_backward_f32_bounded.spv"
	)),
	workgroup_size: [64, 1, 1],
	dispatch_tile_size: [32, 32, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_SILU_MUL_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_silu_mul_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_SILU_MUL_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_silu_mul_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_SILU_MUL_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_silu_mul_backward_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::UpToTwoElements,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_SILU_MUL_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_silu_mul_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::UpToTwoElements,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_GROUPED_GEMM_M_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_grouped_gemm_m_f32.spv")),
	workgroup_size: [64, 1, 1],
	dispatch_tile_size: [32, 32, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_GROUPED_GEMM_M_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_grouped_gemm_m_f32_bounded.spv"
	)),
	workgroup_size: [64, 1, 1],
	dispatch_tile_size: [32, 32, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_GROUPED_GEMM_M_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_grouped_gemm_m_backward_f32.spv"
	)),
	workgroup_size: [64, 1, 1],
	dispatch_tile_size: [32, 32, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_GROUPED_GEMM_M_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_grouped_gemm_m_backward_f32_bounded.spv"
	)),
	workgroup_size: [64, 1, 1],
	dispatch_tile_size: [32, 32, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_GROUPED_GEMM_M_PARAMETER_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_grouped_gemm_m_parameter_backward_f32.spv"
	)),
	workgroup_size: [64, 1, 1],
	dispatch_tile_size: [32, 32, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_GROUPED_GEMM_M_PARAMETER_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_grouped_gemm_m_parameter_backward_f32_bounded.spv"
	)),
	workgroup_size: [64, 1, 1],
	dispatch_tile_size: [32, 32, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_LINEAR_MATCH_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_linear_match_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_LINEAR_MATCH_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_linear_match_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_EULER_STEP_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_euler_step_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_EULER_STEP_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_euler_step_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_MASKED_MSE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_masked_mse_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::Scalar,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::OneScalar,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Scalar,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::OneScalar,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MASKED_MSE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_masked_mse_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::Scalar,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::OneScalar,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Scalar,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::OneScalar,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_MASKED_MSE_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_masked_mse_backward_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 5,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MASKED_MSE_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_masked_mse_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 5,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_GAE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_gae_f32.spv")),
	workgroup_size: [64, 1, 1],
	dispatch_tile_size: [64, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_GAE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_gae_f32_bounded.spv")),
	workgroup_size: [64, 1, 1],
	dispatch_tile_size: [64, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_APPEND_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_append_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 8,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 9,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 10,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 11,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 12,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 13,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 14,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::SharedAtomicContributors,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::AtomicU32,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 15,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::SharedAtomicContributors,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::AtomicU32,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 16,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::SharedAtomicContributors,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::AtomicU32,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_APPEND_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_append_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 8,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 9,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 10,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 11,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 12,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 13,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 14,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::SharedAtomicContributors,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::AtomicU32,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 15,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::SharedAtomicContributors,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::AtomicU32,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 16,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::SharedAtomicContributors,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::AtomicU32,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_RESET_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_reset_u8.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 0,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::SharedAtomicContributors,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::AtomicU32,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_RESET_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_reset_u8_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 0,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::SharedAtomicContributors,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::AtomicU32,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_APPEND_BATCH_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_append_batch_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 7,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 8,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 9,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 10,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::SharedAtomicContributors,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::AtomicU32,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 11,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::SharedAtomicContributors,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::AtomicU32,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_APPEND_BATCH_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_append_batch_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 7,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 8,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 9,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 10,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::SharedAtomicContributors,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::AtomicU32,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 11,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::SharedAtomicContributors,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::AtomicU32,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_SAMPLE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_sample_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 7,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 8,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 9,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 10,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::SharedAtomicContributors,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::AtomicU32,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 11,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::SharedAtomicContributors,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::AtomicU32,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 12,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_SAMPLE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_sample_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 7,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 8,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 9,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 10,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::SharedAtomicContributors,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::AtomicU32,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 11,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::SharedAtomicContributors,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::AtomicU32,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 12,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_DQN_TARGET_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_dqn_target_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 4,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_DQN_TARGET_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_dqn_target_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 4,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_SAC_TARGET_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_sac_target_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 6,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_SAC_TARGET_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_sac_target_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 6,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_CART_POLE_RESET_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_cart_pole_reset_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 0,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::SharedAtomicContributors,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::AtomicU32,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 1,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::UpToFourElements,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 2,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_CART_POLE_RESET_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_cart_pole_reset_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 0,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::SharedAtomicContributors,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::AtomicU32,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 1,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::UpToFourElements,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 2,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_CART_POLE_STEP_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_cart_pole_step_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 1,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::UpToFourElements,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 2,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::UpToFourElements,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::SharedAtomicContributors,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::AtomicU32,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::SharedAtomicContributors,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::AtomicU32,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::SharedAtomicContributors,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::AtomicU32,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 7,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_CART_POLE_STEP_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_cart_pole_step_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 1,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::UpToFourElements,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 2,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::UpToFourElements,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::SharedAtomicContributors,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::AtomicU32,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::SharedAtomicContributors,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::AtomicU32,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::SharedAtomicContributors,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::AtomicU32,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 7,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_LUNAR_LANDER_RESET_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_lunar_lander_reset_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_LUNAR_LANDER_RESET_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_lunar_lander_reset_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_LUNAR_LANDER_STEP_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_lunar_lander_step_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 7,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 8,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 9,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 10,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::SharedAtomicContributors,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::AtomicU32,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 11,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::SharedAtomicContributors,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::AtomicU32,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 12,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_LUNAR_LANDER_STEP_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_lunar_lander_step_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 7,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 8,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 9,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 10,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::SharedAtomicContributors,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::AtomicU32,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 11,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::SharedAtomicContributors,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::AtomicU32,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 12,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_RMS_NORM_GATED_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_rms_norm_gated_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 4,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::RowWidth,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_RMS_NORM_GATED_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_rms_norm_gated_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 4,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::RowWidth,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_RMS_NORM_GATED_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_rms_norm_gated_backward_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 7,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 8,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_RMS_NORM_GATED_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_rms_norm_gated_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 7,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 8,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_MAMBA3_PREPROCESS_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_mamba3_preprocess_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 2,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 7,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 8,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 9,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MAMBA3_PREPROCESS_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_preprocess_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 2,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 7,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 8,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 9,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_MAMBA3_PREPROCESS_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_preprocess_backward_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 10,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 11,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MAMBA3_PREPROCESS_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_preprocess_backward_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 10,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 11,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_MAMBA3_PREPROCESS_BACKWARD_REDUCE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_preprocess_backward_reduce_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MAMBA3_PREPROCESS_BACKWARD_REDUCE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_preprocess_backward_reduce_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_MAMBA3_SISO_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_mamba3_siso_f32.spv")),
	workgroup_size: [128, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 11,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::RowWidth,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MAMBA3_SISO_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_mamba3_siso_f32_bounded.spv")),
	workgroup_size: [128, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 11,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::RowWidth,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_MAMBA3_SISO_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_mamba3_siso_backward_f32.spv")),
	workgroup_size: [64, 1, 1],
	dispatch_tile_size: [64, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 8,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 9,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 10,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 11,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 12,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 13,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 14,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MAMBA3_SISO_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_siso_backward_f32_bounded.spv"
	)),
	workgroup_size: [64, 1, 1],
	dispatch_tile_size: [64, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 8,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 9,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 10,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 11,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 12,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 13,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 14,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_MAMBA3_SISO_STEP_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_mamba3_siso_step_f32.spv")),
	workgroup_size: [128, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 11,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 12,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 13,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 14,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 15,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MAMBA3_SISO_STEP_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_siso_step_f32_bounded.spv"
	)),
	workgroup_size: [128, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 11,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 12,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 13,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 14,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 15,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_MAMBA3_SISO_BACKWARD_STATE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_siso_backward_state_f32.spv"
	)),
	workgroup_size: [16, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 10,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 11,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 12,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MAMBA3_SISO_BACKWARD_STATE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_siso_backward_state_f32_bounded.spv"
	)),
	workgroup_size: [16, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 10,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 11,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 12,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_MAMBA3_SISO_BACKWARD_REVERSE_P16_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_siso_backward_reverse_p16_f32.spv"
	)),
	workgroup_size: [16, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 11,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 12,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 13,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 14,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 15,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 16,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 17,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 18,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 19,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 20,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MAMBA3_SISO_BACKWARD_REVERSE_P16_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_siso_backward_reverse_p16_f32_bounded.spv"
	)),
	workgroup_size: [16, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 11,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 12,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 13,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 14,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 15,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 16,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 17,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 18,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 19,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 20,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_MAMBA3_SISO_BACKWARD_FINALIZE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_siso_backward_finalize_f32.spv"
	)),
	workgroup_size: [64, 1, 1],
	dispatch_tile_size: [64, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 7,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 8,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MAMBA3_SISO_BACKWARD_FINALIZE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_siso_backward_finalize_f32_bounded.spv"
	)),
	workgroup_size: [64, 1, 1],
	dispatch_tile_size: [64, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 7,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 8,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_MAMBA3_SISO_BACKWARD_REDUCE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_siso_backward_reduce_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 7,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MAMBA3_SISO_BACKWARD_REDUCE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_siso_backward_reduce_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 7,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_MAMBA3_SISO_BACKWARD_GROUP_REDUCE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_siso_backward_group_reduce_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 2,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MAMBA3_SISO_BACKWARD_GROUP_REDUCE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_siso_backward_group_reduce_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 2,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_MAMBA3_MIMO_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_mamba3_mimo_f32.spv")),
	workgroup_size: [128, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 15,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::RowWidth,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MAMBA3_MIMO_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_mamba3_mimo_f32_bounded.spv")),
	workgroup_size: [128, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 15,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::RowWidth,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_MAMBA3_MIMO_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_mamba3_mimo_backward_f32.spv")),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 12,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 13,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 14,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 15,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 16,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 17,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 18,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 19,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 20,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MAMBA3_MIMO_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_mimo_backward_f32_bounded.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 12,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 13,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 14,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 15,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 16,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 17,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 18,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 19,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 20,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_MAMBA3_MIMO_STEP_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_mamba3_mimo_step_f32.spv")),
	workgroup_size: [128, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 15,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 16,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 17,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 18,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 19,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MAMBA3_MIMO_STEP_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_mimo_step_f32_bounded.spv"
	)),
	workgroup_size: [128, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 15,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 16,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 17,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 18,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 19,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_MAMBA3_MIMO_BACKWARD_PREPARE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_mimo_backward_prepare_f32.spv"
	)),
	workgroup_size: [128, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 10,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 11,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 12,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 13,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 14,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 15,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 16,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MAMBA3_MIMO_BACKWARD_PREPARE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_mimo_backward_prepare_f32_bounded.spv"
	)),
	workgroup_size: [128, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 10,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 11,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 12,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 13,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 14,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 15,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 16,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_MAMBA3_MIMO_BACKWARD_POST_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_mimo_backward_post_f32.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 13,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 14,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 15,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 16,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 17,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MAMBA3_MIMO_BACKWARD_POST_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_mimo_backward_post_f32_bounded.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 13,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 14,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 15,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 16,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 17,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_MAMBA3_MIMO_BACKWARD_ROTATE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_mimo_backward_rotate_f32.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 9,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 10,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 11,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 12,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 13,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 14,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MAMBA3_MIMO_BACKWARD_ROTATE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_mimo_backward_rotate_f32_bounded.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 9,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 10,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 11,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 12,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 13,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 14,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_MAMBA3_MIMO_BACKWARD_REDUCE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_mimo_backward_reduce_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 10,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 11,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 12,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 13,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 14,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 15,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 16,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 17,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 18,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 19,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MAMBA3_MIMO_BACKWARD_REDUCE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_mimo_backward_reduce_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 10,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 11,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 12,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 13,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 14,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 15,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 16,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 17,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 18,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 19,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_MAMBA3_SISO_BACKWARD_GENERIC_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_siso_backward_generic_f32.spv"
	)),
	workgroup_size: [128, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 12,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 13,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 14,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 15,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 16,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 17,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 18,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 19,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 20,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 21,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 22,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 23,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MAMBA3_SISO_BACKWARD_GENERIC_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_siso_backward_generic_f32_bounded.spv"
	)),
	workgroup_size: [128, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 12,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 13,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 14,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 15,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 16,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 17,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 18,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 19,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 20,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 21,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 22,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 23,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static ML_MAMBA3_SISO_BACKWARD_GENERIC_REDUCE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_siso_backward_generic_reduce_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 7,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 8,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 9,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 10,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 11,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 12,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MAMBA3_SISO_BACKWARD_GENERIC_REDUCE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_siso_backward_generic_reduce_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 7,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 8,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 9,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 10,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 11,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 12,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_MAMBA3_SISO_CHUNK_SUMMARY_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_siso_chunk_summary_f32.spv"
	)),
	workgroup_size: [128, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MAMBA3_SISO_CHUNK_SUMMARY_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_siso_chunk_summary_f32_bounded.spv"
	)),
	workgroup_size: [128, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_MAMBA3_SISO_CHUNK_PREFIX_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_siso_chunk_prefix_f32.spv"
	)),
	workgroup_size: [128, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::RowWidth,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MAMBA3_SISO_CHUNK_PREFIX_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_siso_chunk_prefix_f32_bounded.spv"
	)),
	workgroup_size: [128, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::RowWidth,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_MAMBA3_SISO_CHUNK_DPRE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_siso_chunk_dpre_f32.spv"
	)),
	workgroup_size: [64, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 11,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 12,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 13,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MAMBA3_SISO_CHUNK_DPRE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_siso_chunk_dpre_f32_bounded.spv"
	)),
	workgroup_size: [64, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 11,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 12,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 13,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_MAMBA3_SISO_CHUNK_BACKWARD_SUMMARY_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_siso_chunk_backward_summary_f32.spv"
	)),
	workgroup_size: [128, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::RowWidth,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MAMBA3_SISO_CHUNK_BACKWARD_SUMMARY_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_siso_chunk_backward_summary_f32_bounded.spv"
	)),
	workgroup_size: [128, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::RowWidth,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_MAMBA3_SISO_CHUNK_BACKWARD_PREFIX_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_siso_chunk_backward_prefix_f32.spv"
	)),
	workgroup_size: [128, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::RowWidth,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MAMBA3_SISO_CHUNK_BACKWARD_PREFIX_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_siso_chunk_backward_prefix_f32_bounded.spv"
	)),
	workgroup_size: [128, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::RowWidth,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_MAMBA3_SISO_CHUNK_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_siso_chunk_backward_f32.spv"
	)),
	workgroup_size: [64, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 12,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 13,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 14,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 15,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 16,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 17,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 18,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 19,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MAMBA3_SISO_CHUNK_BACKWARD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_siso_chunk_backward_f32_bounded.spv"
	)),
	workgroup_size: [64, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 12,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 13,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 14,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 15,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 16,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 17,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 18,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 19,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_MAMBA3_SISO_CHUNK_FINALIZE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_siso_chunk_finalize_f32.spv"
	)),
	workgroup_size: [64, 1, 1],
	dispatch_tile_size: [64, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 7,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 8,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MAMBA3_SISO_CHUNK_FINALIZE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_siso_chunk_finalize_f32_bounded.spv"
	)),
	workgroup_size: [64, 1, 1],
	dispatch_tile_size: [64, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 7,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 8,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_MAMBA3_SISO_CHUNK_REDUCE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_siso_chunk_reduce_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 7,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 8,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 9,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_MAMBA3_SISO_CHUNK_REDUCE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_mamba3_siso_chunk_reduce_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 7,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 8,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 9,
				domain: LogicalWriteDomain::OutputElements,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_VQ_ASSIGN_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_vq_assign_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 2,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_VQ_ASSIGN_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_vq_assign_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 2,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_VQ_LOOKUP_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_vq_lookup_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_VQ_LOOKUP_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_vq_lookup_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static ML_VQ_EMA_UPDATE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/ml_vq_ema_update_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 7,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_ML_VQ_EMA_UPDATE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/ml_vq_ema_update_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::OneElement,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 7,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static AUDIO_GAIN_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/audio_gain_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_AUDIO_GAIN_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/audio_gain_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static AUDIO_CLIP_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/audio_clip_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_AUDIO_CLIP_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/audio_clip_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static AUDIO_SATURATE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/audio_saturate_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_AUDIO_SATURATE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/audio_saturate_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static AUDIO_RESAMPLE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/audio_resample_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_AUDIO_RESAMPLE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/audio_resample_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static AUDIO_FADE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/audio_fade_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_AUDIO_FADE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/audio_fade_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static AUDIO_MIX_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/audio_mix_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_AUDIO_MIX_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/audio_mix_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static AUDIO_AMPLITUDE_TO_DB_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/audio_amplitude_to_db_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_AUDIO_AMPLITUDE_TO_DB_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/audio_amplitude_to_db_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static AUDIO_WAVEFORM_ENVELOPE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/audio_waveform_envelope_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_AUDIO_WAVEFORM_ENVELOPE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/audio_waveform_envelope_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static AUDIO_PRE_EMPHASIS_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/audio_pre_emphasis_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_AUDIO_PRE_EMPHASIS_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/audio_pre_emphasis_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static AUDIO_TO_MONO_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/audio_to_mono_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_AUDIO_TO_MONO_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/audio_to_mono_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static AUDIO_NORMALIZE_LEVEL_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/audio_normalize_level_f32.spv")),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_AUDIO_NORMALIZE_LEVEL_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/audio_normalize_level_f32_bounded.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static AUDIO_NORMALIZE_APPLY_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/audio_normalize_apply_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_AUDIO_NORMALIZE_APPLY_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/audio_normalize_apply_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static AUDIO_BIQUAD_SUMMARY_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/audio_biquad_summary_f32.spv")),
	workgroup_size: [64, 1, 1],
	dispatch_tile_size: [64, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_AUDIO_BIQUAD_SUMMARY_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/audio_biquad_summary_f32_bounded.spv"
	)),
	workgroup_size: [64, 1, 1],
	dispatch_tile_size: [64, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static AUDIO_BIQUAD_SCAN_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/audio_biquad_scan_f32.spv")),
	workgroup_size: [64, 1, 1],
	dispatch_tile_size: [64, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_AUDIO_BIQUAD_SCAN_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/audio_biquad_scan_f32_bounded.spv"
	)),
	workgroup_size: [64, 1, 1],
	dispatch_tile_size: [64, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static AUDIO_BIQUAD_APPLY_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/audio_biquad_apply_f32.spv")),
	workgroup_size: [64, 1, 1],
	dispatch_tile_size: [64, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_AUDIO_BIQUAD_APPLY_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/audio_biquad_apply_f32_bounded.spv"
	)),
	workgroup_size: [64, 1, 1],
	dispatch_tile_size: [64, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static AUDIO_REVERB_COMB_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/audio_reverb_comb_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_AUDIO_REVERB_COMB_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/audio_reverb_comb_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static AUDIO_REVERB_SUM_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/audio_reverb_sum_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_AUDIO_REVERB_SUM_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/audio_reverb_sum_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static AUDIO_REVERB_ALLPASS_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/audio_reverb_allpass_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_AUDIO_REVERB_ALLPASS_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/audio_reverb_allpass_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static AUDIO_REVERB_MIX_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/audio_reverb_mix_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_AUDIO_REVERB_MIX_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/audio_reverb_mix_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static AUDIO_STFT_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/audio_stft_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_AUDIO_STFT_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/audio_stft_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static AUDIO_MEL_FILTERBANK_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/audio_mel_filterbank_f32.spv")),
	workgroup_size: [32, 1, 1],
	dispatch_tile_size: [32, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_AUDIO_MEL_FILTERBANK_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/audio_mel_filterbank_f32_bounded.spv"
	)),
	workgroup_size: [32, 1, 1],
	dispatch_tile_size: [32, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static AUDIO_MEL_NORMALIZE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/audio_mel_normalize_f32.spv")),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_AUDIO_MEL_NORMALIZE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/audio_mel_normalize_f32_bounded.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static AUDIO_MFCC_DCT_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/audio_mfcc_dct_f32.spv")),
	workgroup_size: [32, 1, 1],
	dispatch_tile_size: [32, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_AUDIO_MFCC_DCT_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/audio_mfcc_dct_f32_bounded.spv")),
	workgroup_size: [32, 1, 1],
	dispatch_tile_size: [32, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static AUDIO_SOS_FILTER_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/audio_sos_filter_f32.spv")),
	workgroup_size: [64, 1, 1],
	dispatch_tile_size: [64, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_AUDIO_SOS_FILTER_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/audio_sos_filter_f32_bounded.spv"
	)),
	workgroup_size: [64, 1, 1],
	dispatch_tile_size: [64, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static CRYPTOGRAPHY_SHAKE128_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/cryptography_shake128_u8.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_CRYPTOGRAPHY_SHAKE128_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/cryptography_shake128_u8_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static CRYPTOGRAPHY_SHAKE256_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/cryptography_shake256_u8.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_CRYPTOGRAPHY_SHAKE256_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/cryptography_shake256_u8_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static CRYPTOGRAPHY_KECCAK_F1600_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/cryptography_keccak_f1600_u8.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_CRYPTOGRAPHY_KECCAK_F1600_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/cryptography_keccak_f1600_u8_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static CRYPTOGRAPHY_MERKLE_REDUCE_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/cryptography_merkle_reduce_u8.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_CRYPTOGRAPHY_MERKLE_REDUCE_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/cryptography_merkle_reduce_u8_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static CRYPTOGRAPHY_MERKLE_COPY_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/cryptography_merkle_copy_u8.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_CRYPTOGRAPHY_MERKLE_COPY_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/cryptography_merkle_copy_u8_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static CRYPTOGRAPHY_ML_DSA_65_VERIFY_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/cryptography_ml_dsa_65_verify_u8.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_CRYPTOGRAPHY_ML_DSA_65_VERIFY_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/cryptography_ml_dsa_65_verify_u8_bounded.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static CRYPTOGRAPHY_ML_DSA_44_VERIFY_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/cryptography_ml_dsa_44_verify_u8.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_CRYPTOGRAPHY_ML_DSA_44_VERIFY_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/cryptography_ml_dsa_44_verify_u8_bounded.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static CRYPTOGRAPHY_ML_DSA_87_VERIFY_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/cryptography_ml_dsa_87_verify_u8.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_CRYPTOGRAPHY_ML_DSA_87_VERIFY_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/cryptography_ml_dsa_87_verify_u8_bounded.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static CRYPTOGRAPHY_ML_DSA_65_VERIFY_PREHASHED_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/cryptography_ml_dsa_65_verify_prehashed_u8.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_CRYPTOGRAPHY_ML_DSA_65_VERIFY_PREHASHED_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/cryptography_ml_dsa_65_verify_prehashed_u8_bounded.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static CRYPTOGRAPHY_ML_DSA_44_VERIFY_PREHASHED_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/cryptography_ml_dsa_44_verify_prehashed_u8.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_CRYPTOGRAPHY_ML_DSA_44_VERIFY_PREHASHED_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/cryptography_ml_dsa_44_verify_prehashed_u8_bounded.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static CRYPTOGRAPHY_ML_DSA_87_VERIFY_PREHASHED_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/cryptography_ml_dsa_87_verify_prehashed_u8.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_CRYPTOGRAPHY_ML_DSA_87_VERIFY_PREHASHED_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/cryptography_ml_dsa_87_verify_prehashed_u8_bounded.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static CRYPTOGRAPHY_ML_DSA_65_VERIFY_HASH_MESSAGE_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/cryptography_ml_dsa_65_verify_hash_message_u8.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_CRYPTOGRAPHY_ML_DSA_65_VERIFY_HASH_MESSAGE_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/cryptography_ml_dsa_65_verify_hash_message_u8_bounded.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static CRYPTOGRAPHY_ML_DSA_44_VERIFY_HASH_MESSAGE_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/cryptography_ml_dsa_44_verify_hash_message_u8.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_CRYPTOGRAPHY_ML_DSA_44_VERIFY_HASH_MESSAGE_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/cryptography_ml_dsa_44_verify_hash_message_u8_bounded.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static CRYPTOGRAPHY_ML_DSA_87_VERIFY_HASH_MESSAGE_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/cryptography_ml_dsa_87_verify_hash_message_u8.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static BOUNDED_CRYPTOGRAPHY_ML_DSA_87_VERIFY_HASH_MESSAGE_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/cryptography_ml_dsa_87_verify_hash_message_u8_bounded.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: None,
	content_id: OnceLock::new(),
};

static CRYPTOGRAPHY_ML_KEM_KEYGEN_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/cryptography_ml_kem_keygen_u8.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 1,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 2,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_CRYPTOGRAPHY_ML_KEM_KEYGEN_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/cryptography_ml_kem_keygen_u8_bounded.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 1,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 2,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static CRYPTOGRAPHY_ML_KEM_ENCAPS_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/cryptography_ml_kem_encaps_u8.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 2,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_CRYPTOGRAPHY_ML_KEM_ENCAPS_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/cryptography_ml_kem_encaps_u8_bounded.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 2,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static CRYPTOGRAPHY_ML_KEM_DECAPS_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/cryptography_ml_kem_decaps_u8.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::RowWidth,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_CRYPTOGRAPHY_ML_KEM_DECAPS_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/cryptography_ml_kem_decaps_u8_bounded.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::Rows,
			partition: WritePartition::ExclusivePerWorkgroup,
			extent: WriteExtent::RowWidth,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static CRYPTOGRAPHY_ML_DSA_KEYGEN_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/cryptography_ml_dsa_keygen_u8.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 1,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 2,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_CRYPTOGRAPHY_ML_DSA_KEYGEN_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/cryptography_ml_dsa_keygen_u8_bounded.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 1,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 2,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static CRYPTOGRAPHY_ML_DSA_SIGN_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/cryptography_ml_dsa_sign_u8.spv")),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_CRYPTOGRAPHY_ML_DSA_SIGN_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/cryptography_ml_dsa_sign_u8_bounded.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static CRYPTOGRAPHY_ML_DSA_SIGN_MESSAGE_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/cryptography_ml_dsa_sign_message_u8.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_CRYPTOGRAPHY_ML_DSA_SIGN_MESSAGE_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/cryptography_ml_dsa_sign_message_u8_bounded.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static CRYPTOGRAPHY_ML_DSA_SIGN_PREHASHED_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/cryptography_ml_dsa_sign_prehashed_u8.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_CRYPTOGRAPHY_ML_DSA_SIGN_PREHASHED_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/cryptography_ml_dsa_sign_prehashed_u8_bounded.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static CRYPTOGRAPHY_ML_DSA_SIGN_HASH_MESSAGE_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/cryptography_ml_dsa_sign_hash_message_u8.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_CRYPTOGRAPHY_ML_DSA_SIGN_HASH_MESSAGE_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/cryptography_ml_dsa_sign_hash_message_u8_bounded.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 5,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 6,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::ExclusivePerWorkgroup,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_RESIZE_NEAREST_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_resize_nearest_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_RESIZE_NEAREST_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_resize_nearest_f32_bounded.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_RESIZE_BILINEAR_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_resize_bilinear_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_RESIZE_BILINEAR_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_resize_bilinear_f32_bounded.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_CROP_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_crop_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_CROP_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_crop_f32_bounded.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_FLIP_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_flip_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_FLIP_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_flip_f32_bounded.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_ROTATE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_rotate_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_ROTATE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_rotate_f32_bounded.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_PAD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_pad_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_PAD_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_pad_f32_bounded.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_CENTER_CROP_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_center_crop_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_CENTER_CROP_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_center_crop_f32_bounded.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_REMAP_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_remap_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_REMAP_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_remap_f32_bounded.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_WARP_AFFINE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_warp_affine_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_WARP_AFFINE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_warp_affine_f32_bounded.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_WARP_PERSPECTIVE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_warp_perspective_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_WARP_PERSPECTIVE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_warp_perspective_f32_bounded.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_THRESHOLD_BINARY_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_threshold_binary_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_THRESHOLD_BINARY_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_threshold_binary_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_THRESHOLD_BINARY_INV_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_threshold_binary_inv_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_THRESHOLD_BINARY_INV_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_threshold_binary_inv_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_THRESHOLD_TRUNCATE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_threshold_truncate_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_THRESHOLD_TRUNCATE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_threshold_truncate_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_THRESHOLD_TO_ZERO_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_threshold_to_zero_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_THRESHOLD_TO_ZERO_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_threshold_to_zero_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_THRESHOLD_TO_ZERO_INV_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_threshold_to_zero_inv_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_THRESHOLD_TO_ZERO_INV_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_threshold_to_zero_inv_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_IN_RANGE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_in_range_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_IN_RANGE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_in_range_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_CLAMP_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_clamp_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_CLAMP_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_clamp_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_INVERT_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_invert_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_INVERT_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_invert_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_BRIGHTNESS_CONTRAST_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_brightness_contrast_f32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_BRIGHTNESS_CONTRAST_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_brightness_contrast_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_GAMMA_CONTRAST_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_gamma_contrast_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_GAMMA_CONTRAST_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_gamma_contrast_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_SOLARIZE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_solarize_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_SOLARIZE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_solarize_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_POSTERIZE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_posterize_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_POSTERIZE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_posterize_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_GRAYSCALE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_grayscale_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_GRAYSCALE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_grayscale_f32_bounded.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_ALPHA_BLEND_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_alpha_blend_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_ALPHA_BLEND_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_alpha_blend_f32_bounded.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_COMPOSITE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_composite_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_COMPOSITE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_composite_f32_bounded.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_ERASE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_erase_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_ERASE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_erase_f32_bounded.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_COLOR_TWIST_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_color_twist_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_COLOR_TWIST_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_color_twist_f32_bounded.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_CHANNEL_REORDER_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_channel_reorder_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_CHANNEL_REORDER_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_channel_reorder_f32_bounded.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_GAUSSIAN_NOISE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_gaussian_noise_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::UpToTwoElements,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_GAUSSIAN_NOISE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_gaussian_noise_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::UpToTwoElements,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_SALT_PEPPER_NOISE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_salt_pepper_noise_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::UpToFourElements,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_SALT_PEPPER_NOISE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_salt_pepper_noise_f32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::UpToFourElements,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_CONVOLVE_2D_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_convolve_2d_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_CONVOLVE_2D_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_convolve_2d_f32_bounded.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_SEPARABLE_CONVOLVE_2D_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_separable_convolve_2d_f32.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_SEPARABLE_CONVOLVE_2D_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_separable_convolve_2d_f32_bounded.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_AVERAGE_BLUR_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_average_blur_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_AVERAGE_BLUR_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_average_blur_f32_bounded.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_SOBEL_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_sobel_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_SOBEL_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_sobel_f32_bounded.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_SCHARR_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_scharr_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_SCHARR_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_scharr_f32_bounded.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_LAPLACIAN_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_laplacian_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_LAPLACIAN_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_laplacian_f32_bounded.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_ERODE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_erode_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_ERODE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_erode_f32_bounded.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_DILATE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_dilate_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_DILATE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_dilate_f32_bounded.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_MORPHOLOGY_OPEN_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_morphology_open_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_MORPHOLOGY_OPEN_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_morphology_open_f32_bounded.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_MORPHOLOGY_CLOSE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_morphology_close_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_MORPHOLOGY_CLOSE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_morphology_close_f32_bounded.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_MORPHOLOGY_GRADIENT_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_morphology_gradient_f32.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_MORPHOLOGY_GRADIENT_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_morphology_gradient_f32_bounded.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_GAUSSIAN_BLUR_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_gaussian_blur_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_GAUSSIAN_BLUR_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_gaussian_blur_f32_bounded.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_SHARPEN_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_sharpen_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_SHARPEN_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_sharpen_f32_bounded.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_MEDIAN_BLUR_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_median_blur_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_MEDIAN_BLUR_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_median_blur_f32_bounded.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_BILATERAL_FILTER_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_bilateral_filter_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_BILATERAL_FILTER_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_bilateral_filter_f32_bounded.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_UNSHARP_MASK_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_unsharp_mask_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_UNSHARP_MASK_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_unsharp_mask_f32_bounded.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_MORPHOLOGY_TOP_HAT_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_morphology_top_hat_f32.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_MORPHOLOGY_TOP_HAT_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_morphology_top_hat_f32_bounded.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_MORPHOLOGY_BLACK_HAT_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_morphology_black_hat_f32.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_MORPHOLOGY_BLACK_HAT_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_morphology_black_hat_f32_bounded.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_ADAPTIVE_THRESHOLD_MEAN_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_adaptive_threshold_mean_f32.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_ADAPTIVE_THRESHOLD_MEAN_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_adaptive_threshold_mean_f32_bounded.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_ADAPTIVE_THRESHOLD_GAUSSIAN_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_adaptive_threshold_gaussian_f32.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_ADAPTIVE_THRESHOLD_GAUSSIAN_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_adaptive_threshold_gaussian_f32_bounded.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_NORMALIZE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_normalize_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_NORMALIZE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_normalize_f32_bounded.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_CONVERT_COLOR_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_convert_color_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_CONVERT_COLOR_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_convert_color_f32_bounded.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_RESIZE_NORMALIZE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/image_resize_normalize_f32.spv")),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_RESIZE_NORMALIZE_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_resize_normalize_f32_bounded.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 1,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static IMAGE_SEGMENTATION_OVERLAY_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_segmentation_overlay_f32.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_IMAGE_SEGMENTATION_OVERLAY_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/image_segmentation_overlay_f32_bounded.spv"
	)),
	workgroup_size: [16, 16, 1],
	dispatch_tile_size: [16, 16, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 3,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static VISION_BOX_IOU_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/vision_box_iou_f32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_VISION_BOX_IOU_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/vision_box_iou_f32_bounded.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static VISION_NMS_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/vision_nms_f32.spv")),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Scalar,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::OneScalar,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_VISION_NMS_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/vision_nms_f32_bounded.spv")),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 4,
				domain: LogicalWriteDomain::Scalar,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::OneScalar,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static VISION_CONFUSION_MATRIX_I32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(env!("OUT_DIR"), "/vision_confusion_matrix_i32.spv")),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::SharedAtomicContributors,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::AtomicU32,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_VISION_CONFUSION_MATRIX_I32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/vision_confusion_matrix_i32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::SharedAtomicContributors,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::AtomicU32,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static VISION_BINARY_MASK_COUNTS_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/vision_binary_mask_counts_u8.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::SharedAtomicContributors,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::AtomicU32,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_VISION_BINARY_MASK_COUNTS_U8: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/vision_binary_mask_counts_u8_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::SharedAtomicContributors,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::AtomicU32,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static VISION_DETECTION_METRIC_CURVES_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/vision_detection_metric_curves_f32.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 8,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 9,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 10,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 11,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_VISION_DETECTION_METRIC_CURVES_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/vision_detection_metric_curves_f32_bounded.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 8,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 9,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 10,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 11,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerInvocation,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static VISION_DETECTION_AVERAGE_PRECISION_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/vision_detection_average_precision_f32.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_VISION_DETECTION_AVERAGE_PRECISION_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/vision_detection_average_precision_f32_bounded.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static VISION_DETECTION_MEAN_AVERAGE_PRECISION_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/vision_detection_mean_average_precision_f32.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 2,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::Scalar,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::OneScalar,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_VISION_DETECTION_MEAN_AVERAGE_PRECISION_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/vision_detection_mean_average_precision_f32_bounded.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 2,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::Scalar,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::OneScalar,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static VISION_SEGMENTATION_CONFUSION_I32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/vision_segmentation_confusion_i32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::SharedAtomicContributors,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::AtomicU32,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_VISION_SEGMENTATION_CONFUSION_I32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/vision_segmentation_confusion_i32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 2,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::SharedAtomicContributors,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::AtomicU32,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static VISION_SEGMENTATION_METRICS_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/vision_segmentation_metrics_f32.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 1,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 2,
				domain: LogicalWriteDomain::Scalar,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::OneScalar,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::Scalar,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::OneScalar,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_VISION_SEGMENTATION_METRICS_F32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/vision_segmentation_metrics_f32_bounded.spv"
	)),
	workgroup_size: [1, 1, 1],
	dispatch_tile_size: [1, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[
			PhysicalWrite {
				binding: 1,
				domain: LogicalWriteDomain::Rows,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::RowWidth,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 2,
				domain: LogicalWriteDomain::Scalar,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::OneScalar,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
			PhysicalWrite {
				binding: 3,
				domain: LogicalWriteDomain::Scalar,
				partition: WritePartition::ExclusivePerWorkgroup,
				extent: WriteExtent::OneScalar,
				collision: CollisionPolicy::Exclusive,
				tail: TailPolicy::BoundsChecked,
			},
		],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static VISION_CONFUSION_MATRIX_CLEAR_U32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/vision_confusion_matrix_clear_u32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 0,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_VISION_CONFUSION_MATRIX_CLEAR_U32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/vision_confusion_matrix_clear_u32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 0,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static VISION_BINARY_MASK_COUNTS_CLEAR_U32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/vision_binary_mask_counts_clear_u32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 0,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_VISION_BINARY_MASK_COUNTS_CLEAR_U32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/vision_binary_mask_counts_clear_u32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 0,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static VISION_SEGMENTATION_CONFUSION_CLEAR_U32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/vision_segmentation_confusion_clear_u32.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 0,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

static BOUNDED_VISION_SEGMENTATION_CONFUSION_CLEAR_U32: ShaderArtifact = ShaderArtifact {
	bytes: include_bytes!(concat!(
		env!("OUT_DIR"),
		"/vision_segmentation_confusion_clear_u32_bounded.spv"
	)),
	workgroup_size: [256, 1, 1],
	dispatch_tile_size: [256, 1, 1],
	physical_write: Some(PhysicalWriteContract {
		writes: &[PhysicalWrite {
			binding: 0,
			domain: LogicalWriteDomain::OutputElements,
			partition: WritePartition::ExclusivePerInvocation,
			extent: WriteExtent::OneElement,
			collision: CollisionPolicy::Exclusive,
			tail: TailPolicy::BoundsChecked,
		}],
		workspace: WorkspacePartition::None,
	}),
	content_id: OnceLock::new(),
};

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum TrainingReplayRole {
	Safe,
	HostSteppedOptimizer,
	OptimizerStateAdvance,
	OptimizerStateUpdate,
	FrozenRng,
	ReplayRng,
	RngStateAdvance,
}

#[repr(u16)]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum KernelId {
	MatrixAddF32 = 1,
	MatrixAddI32 = 20,
	MatrixAddBroadcastF32 = 373,
	MatrixAddBroadcastI32 = 374,
	MatrixSubF32 = 2,
	MatrixSubBroadcastF32 = 394,
	MatrixMulF32 = 3,
	MatrixMulBroadcastF32 = 375,
	MatrixDivF32 = 4,
	MatrixDivBroadcastF32 = 395,
	MatrixScaleF32 = 5,
	MatrixNegF32 = 6,
	MatrixAbsF32 = 7,
	MatrixLogF32 = 8,
	MatrixSqrtF32 = 9,
	MatrixPowF32 = 10,
	MatrixAddScalarF32 = 11,
	MatrixSubScalarF32 = 12,
	MatrixDivScalarF32 = 13,
	MatrixExpF32 = 14,
	MatrixSinF32 = 15,
	MatrixCosF32 = 16,
	MatrixReciprocalF32 = 17,
	MatrixClampMaxF32 = 18,
	MatrixClampMinF32 = 19,
	MatrixCopyF32 = 400,
	MatrixCopyU8 = 401,
	MatrixCopyI32 = 402,
	MatrixCopyU32 = 403,
	MatrixMatMulNtTiledF32 = 21,
	MatrixSoftmaxF32 = 118,
	MatrixSoftmaxBackwardF32 = 119,
	MatrixLogSoftmaxF32 = 270,
	MatrixLogSoftmaxBackwardF32 = 271,
	MatrixSumF32 = 120,
	MatrixSumAxisF32 = 121,
	MatrixSumBackwardF32 = 122,
	MatrixCategoricalAccuracyCountF32 = 310,
	MatrixMaskedCategoricalAccuracyCountF32 = 234,
	MatrixPhiloxUniformF32 = 48,
	MatrixPhiloxNormalF32 = 49,
	MatrixPhiloxUniformReplayF32 = 50,
	MatrixPhiloxNormalReplayF32 = 51,
	MatrixPhiloxReplayAdvanceU32 = 52,
	MatrixDropoutF32 = 53,
	MatrixDropoutBackwardF32 = 54,
	MatrixSampleLogitsGreedyF32 = 390,
	MatrixSampleLogitsDenseF32 = 391,
	MatrixSampleLogitsSortedF32 = 392,
	MatrixDropoutReplayF32 = 55,
	MatrixDropoutBackwardReplayF32 = 56,
	MatrixTopKF32 = 195,
	MatrixTopKMaskF32 = 348,
	MatrixMoeExpertPlanU32 = 359,
	MatrixMoeRoutingBiasUpdateF32 = 372,
	MatrixSliceF32 = 376,
	MatrixSliceBackwardF32 = 377,
	MatrixRepeatInterleaveF32 = 344,
	MatrixRepeatInterleaveBackwardF32 = 345,
	MatrixGatherF32 = 441,
	MatrixGatherBackwardF32 = 442,
	MatrixGatherLastDimF32 = 388,
	MatrixGatherLastDimBackwardF32 = 389,
	MatrixConcatF32 = 378,
	MatrixTransposeF32 = 440,
	MatrixEqualF32 = 393,
	MlPpoClippedPolicyF32 = 396,
	MlPpoClippedPolicyBackwardF32 = 397,
	MlLinearF32 = 22,
	MlLinearBackwardF32 = 23,
	MlLinearParameterBackwardF32 = 38,
	MlCrossEntropyF32 = 24,
	MlCrossEntropySumF32 = 57,
	MlCrossEntropyBackwardF32 = 25,
	MlMaskedCrossEntropyF32 = 232,
	MlMaskedCrossEntropyBackwardF32 = 233,
	MlSmoothL1F32 = 297,
	MlSmoothL1BackwardF32 = 298,
	MlSmoothL1MeanF32 = 358,
	MlMseF32 = 299,
	MlMseBackwardF32 = 300,
	MlL1F32 = 301,
	MlL1BackwardF32 = 302,
	MlBceF32 = 303,
	MlBceBackwardF32 = 304,
	MlSgdF32 = 82,
	MlClipGradNormReduceF32 = 351,
	MlClipGradNormScaleF32 = 352,
	MlSgdMomentumF32 = 83,
	MlAdamF32 = 84,
	MlMuonNesterovF32 = 85,
	MlMuonVectorF32 = 86,
	MlMuonNormalizeF32 = 87,
	MlMuonMatMulAxpbyF32 = 88,
	MlMuonLinearCombinationF32 = 89,
	MlMuonTransposeF32 = 90,
	MlMuonApplyF32 = 91,
	MlAdamWF32 = 26,
	MlAdamWGraphAdvanceU32 = 40,
	MlAdamWGraphF32 = 41,
	MlEmbeddingF32 = 27,
	MlEmbeddingBackwardF32 = 28,
	MlChannelNormF32 = 443,
	MlChannelNormBackwardF32 = 444,
	MlChannelNormReluF32 = 445,
	MlChannelNormReluBackwardF32 = 446,
	MlEmbeddingU8F32 = 438,
	MlEmbeddingBackwardU8F32 = 439,
	MlRnnScanF32 = 29,
	MlRnnScanBackwardF32 = 30,
	MlLayerNormF32 = 31,
	MlLayerNormBackwardF32 = 32,
	MlRmsNormF32 = 113,
	MlRmsNormBackwardF32 = 114,
	MlGeluF32 = 33,
	MlGeluBackwardF32 = 34,
	MlSiluF32 = 92,
	MlSiluBackwardF32 = 93,
	MlReluF32 = 94,
	MlReluBackwardF32 = 95,
	MlTanhF32 = 96,
	MlTanhBackwardF32 = 97,
	MlSigmoidF32 = 98,
	MlSigmoidBackwardF32 = 99,
	MlLeakyReluF32 = 100,
	MlLeakyReluBackwardF32 = 101,
	MlEluF32 = 102,
	MlEluBackwardF32 = 103,
	MlMishF32 = 104,
	MlMishBackwardF32 = 105,
	MlSoftplusF32 = 106,
	MlSoftplusBackwardF32 = 107,
	MlQkvProjectionBiasF32 = 42,
	MlSwigluF32 = 43,
	MlSwigluBackwardF32 = 44,
	MlGateUpSwigluBiasF32 = 45,
	MlAdamWMany4F32 = 46,
	MlAdamWMany4GraphF32 = 47,
	MlRopeF32 = 116,
	MlRopeBackwardF32 = 117,
	MlAvgPool2dF32 = 272,
	MlAvgPool2dBackwardF32 = 273,
	MlMaxPool2dF32 = 274,
	MlMaxPool2dBackwardF32 = 275,
	MlAdaptiveAvgPool2dF32 = 276,
	MlAdaptiveAvgPool2dBackwardF32 = 277,
	MlBatchNorm2dF32 = 278,
	MlBatchNorm2dWithStatsF32 = 279,
	MlBatchNorm2dRunningUpdateF32 = 280,
	MlBatchNorm2dBackwardF32 = 281,
	MlBatchNorm2dInputBackwardF32 = 282,
	MlUpsample2dNearestF32 = 283,
	MlUpsample2dBilinearF32 = 284,
	MlUpsample2dNearestBackwardF32 = 285,
	MlUpsample2dBilinearBackwardF32 = 286,
	MlConv2dF32 = 287,
	MlConv2dBackwardF32 = 288,
	MlConv2dParameterBackwardF32 = 289,
	MlConv1dIm2ColF32 = 290,
	MlConv1dBiasAddF32 = 291,
	MlConv1dTransposeF32 = 292,
	MlConv1dBackwardF32 = 293,
	MlConv1dParameterBackwardF32 = 294,
	MlConvTranspose1dF32 = 295,
	MlConvTranspose1dBackwardF32 = 296,
	MlConvTranspose2dF32 = 305,
	MlConvTranspose2dBiasAddF32 = 306,
	MlConvTranspose2dBackwardF32 = 307,
	MlConvTranspose2dParameterBackwardF32 = 308,
	MlGruScanF32 = 311,
	MlGruScanBackwardF32 = 312,
	MlGruCellF32 = 313,
	MlGruCellBackwardF32 = 314,
	MlRnnCellF32 = 315,
	MlRnnCellBackwardF32 = 316,
	MlBmmF32 = 317,
	MlBmmTiled16F32 = 318,
	MlBmmNtF32 = 319,
	MlBmmNtTiled16F32 = 320,
	MlBmmTnF32 = 321,
	MlBmmTnTiled16F32 = 322,
	MlSplitHeadsF32 = 323,
	MlMergeHeadsF32 = 324,
	MlSoftmaxScaledMaskedF32 = 325,
	MlSoftmaxScaledMaskedN32F32 = 326,
	MlSoftmaxScaledMaskedBackwardF32 = 327,
	MlSdpaSoftmaxF32 = 328,
	MlSdpaSoftmaxN32F32 = 329,
	MlFlashAttentionCausalF32 = 330,
	MlFlashAttentionCausalBackwardQF32 = 331,
	MlFlashAttentionCausalBackwardKvF32 = 332,
	MlMoeRouteWeightsF32 = 333,
	MlMoeRouteWeightsBackwardF32 = 334,
	MlMoeGatherF32 = 360,
	MlMoeGatherBackwardF32 = 361,
	MlMoeCombineF32 = 362,
	MlMoeCombineBackwardF32 = 363,
	MlGroupedLinearMF32 = 364,
	MlGroupedLinearMDataBackwardF32 = 365,
	MlGroupedLinearMParameterBackwardF32 = 366,
	MlSiluMulF32 = 367,
	MlSiluMulBackwardF32 = 368,
	MlGroupedGemmMF32 = 369,
	MlGroupedGemmMDataBackwardF32 = 370,
	MlGroupedGemmMParameterBackwardF32 = 371,
	MlFlowLinearMatchF32 = 379,
	MlFlowEulerStepF32 = 380,
	MlFlowMaskedMseF32 = 381,
	MlFlowMaskedMseBackwardF32 = 382,
	MlGaeF32 = 383,
	MlRolloutAppendF32 = 384,
	MlRolloutResetU8 = 385,
	MlReplayAppendBatchF32 = 386,
	MlReplaySampleF32 = 387,
	MlDqnTargetF32 = 398,
	MlSacTargetF32 = 399,
	MlCartPoleResetF32 = 404,
	MlCartPoleStepF32 = 405,
	MlLunarLanderResetF32 = 406,
	MlLunarLanderStepF32 = 407,
	MlRmsNormGatedF32 = 419,
	MlRmsNormGatedBackwardF32 = 420,
	MlMamba3PreprocessF32 = 416,
	MlMamba3PreprocessBackwardF32 = 417,
	MlMamba3PreprocessBackwardReduceF32 = 418,
	MlMamba3SisoF32 = 342,
	MlMamba3SisoBackwardPrepareF32 = 341,
	MlMamba3SisoStepF32 = 343,
	MlMamba3SisoBackwardStateF32 = 411,
	MlMamba3SisoBackwardReverseP16F32 = 412,
	MlMamba3SisoBackwardFinalizeF32 = 413,
	MlMamba3SisoBackwardReduceF32 = 414,
	MlMamba3SisoBackwardGroupReduceF32 = 415,
	MlMamba3MimoF32 = 421,
	MlMamba3MimoBackwardCoreF32 = 422,
	MlMamba3MimoStepF32 = 423,
	MlMamba3MimoBackwardPrepareF32 = 424,
	MlMamba3MimoBackwardPostF32 = 425,
	MlMamba3MimoBackwardRotateF32 = 426,
	MlMamba3MimoBackwardReduceF32 = 427,
	MlMamba3SisoBackwardGenericF32 = 428,
	MlMamba3SisoBackwardGenericReduceF32 = 429,
	MlMamba3SisoChunkSummaryF32 = 430,
	MlMamba3SisoChunkPrefixF32 = 431,
	MlMamba3SisoChunkDpreF32 = 432,
	MlMamba3SisoChunkBackwardSummaryF32 = 433,
	MlMamba3SisoChunkBackwardPrefixF32 = 434,
	MlMamba3SisoChunkBackwardF32 = 435,
	MlMamba3SisoChunkFinalizeF32 = 436,
	MlMamba3SisoChunkReduceF32 = 437,
	MlVqAssignF32 = 408,
	MlVqLookupF32 = 409,
	MlVqEmaUpdateF32 = 410,
	AudioGainF32 = 58,
	AudioClipF32 = 59,
	AudioSaturateF32 = 60,
	AudioResampleF32 = 61,
	AudioFadeF32 = 62,
	AudioMixF32 = 63,
	AudioAmplitudeToDbF32 = 64,
	AudioWaveformEnvelopeF32 = 65,
	AudioPreEmphasisF32 = 66,
	AudioToMonoF32 = 67,
	AudioNormalizeLevelF32 = 68,
	AudioNormalizeApplyF32 = 69,
	AudioBiquadSummaryF32 = 70,
	AudioBiquadScanF32 = 71,
	AudioBiquadApplyF32 = 72,
	AudioReverbCombF32 = 73,
	AudioReverbSumF32 = 74,
	AudioReverbAllpassF32 = 75,
	AudioReverbMixF32 = 76,
	AudioStftF32 = 77,
	AudioMelFilterbankF32 = 78,
	AudioMelNormalizeF32 = 79,
	AudioMfccDctF32 = 80,
	AudioSosFilterF32 = 81,
	CryptographyShake128U8 = 200,
	CryptographyShake256U8 = 201,
	CryptographyKeccakF1600U8 = 202,
	CryptographyMerkleReduceU8 = 203,
	CryptographyMerkleCopyU8 = 204,
	CryptographyMlDsa65VerifyU8 = 205,
	CryptographyMlDsa44VerifyU8 = 457,
	CryptographyMlDsa87VerifyU8 = 458,
	CryptographyMlDsa65VerifyPrehashedU8 = 466,
	CryptographyMlDsa44VerifyPrehashedU8 = 467,
	CryptographyMlDsa87VerifyPrehashedU8 = 468,
	CryptographyMlDsa65VerifyHashMessageU8 = 470,
	CryptographyMlDsa44VerifyHashMessageU8 = 471,
	CryptographyMlDsa87VerifyHashMessageU8 = 472,
	CryptographyMlKemKeygenU8 = 459,
	CryptographyMlKemEncapsU8 = 460,
	CryptographyMlKemDecapsU8 = 461,
	CryptographyMlDsaKeygenU8 = 462,
	CryptographyMlDsaSignU8 = 463,
	CryptographyMlDsaSignMessageU8 = 464,
	CryptographyMlDsaSignPrehashedU8 = 465,
	CryptographyMlDsaSignHashMessageU8 = 469,
	ImageResizeNearestF32 = 123,
	ImageResizeBilinearF32 = 124,
	ImageCropF32 = 137,
	ImageFlipF32 = 138,
	ImageRotateF32 = 139,
	ImagePadF32 = 140,
	ImageCenterCropF32 = 141,
	ImageRemapF32 = 142,
	ImageWarpAffineF32 = 143,
	ImageWarpPerspectiveF32 = 144,
	ImageThresholdBinaryF32 = 145,
	ImageThresholdBinaryInvF32 = 146,
	ImageThresholdTruncateF32 = 147,
	ImageThresholdToZeroF32 = 148,
	ImageThresholdToZeroInvF32 = 149,
	ImageInRangeF32 = 150,
	ImageClampF32 = 151,
	ImageInvertF32 = 152,
	ImageBrightnessContrastF32 = 153,
	ImageGammaContrastF32 = 154,
	ImageSolarizeF32 = 155,
	ImagePosterizeF32 = 156,
	ImageGrayscaleF32 = 157,
	ImageAlphaBlendF32 = 158,
	ImageCompositeF32 = 159,
	ImageEraseF32 = 160,
	ImageColorTwistF32 = 161,
	ImageChannelReorderF32 = 162,
	ImageGaussianNoiseF32 = 163,
	ImageSaltPepperNoiseF32 = 164,
	ImageConvolve2dF32 = 165,
	ImageSeparableConvolve2dF32 = 166,
	ImageAverageBlurF32 = 167,
	ImageSobelF32 = 168,
	ImageScharrF32 = 169,
	ImageLaplacianF32 = 170,
	ImageErodeF32 = 171,
	ImageDilateF32 = 172,
	ImageMorphologyOpenF32 = 173,
	ImageMorphologyCloseF32 = 174,
	ImageMorphologyGradientF32 = 175,
	ImageGaussianBlurF32 = 176,
	ImageSharpenF32 = 177,
	ImageMedianBlurF32 = 178,
	ImageBilateralFilterF32 = 179,
	ImageUnsharpMaskF32 = 180,
	ImageMorphologyTopHatF32 = 181,
	ImageMorphologyBlackHatF32 = 182,
	ImageAdaptiveThresholdMeanF32 = 183,
	ImageAdaptiveThresholdGaussianF32 = 184,
	ImageNormalizeF32 = 185,
	ImageConvertColorF32 = 186,
	ImageResizeNormalizeF32 = 187,
	ImageSegmentationOverlayF32 = 188,
	VisionBoxIouF32 = 125,
	VisionNmsF32 = 126,
	VisionConfusionMatrixI32 = 127,
	VisionBinaryMaskCountsU8 = 128,
	VisionDetectionMetricCurvesF32 = 129,
	VisionDetectionAveragePrecisionF32 = 130,
	VisionDetectionMeanAveragePrecisionF32 = 131,
	VisionSegmentationConfusionI32 = 132,
	VisionSegmentationMetricsF32 = 133,
	VisionConfusionMatrixClearU32 = 134,
	VisionBinaryMaskCountsClearU32 = 135,
	VisionSegmentationConfusionClearU32 = 136,
}

impl KernelId {
	pub(crate) const fn mldsa_keygen_layout(parameter: u32) -> Option<(u64, u64, u64)> {
		match parameter {
			44 => Some((32, 1312, 2560)),
			65 => Some((32, 1952, 4032)),
			87 => Some((32, 2592, 4896)),
			_ => None,
		}
	}
	pub(crate) const fn mldsa_sign_layout(parameter: u32) -> Option<(u64, u64, u64, u64)> {
		match parameter {
			44 => Some((32, 2560, 64, 2420)),
			65 => Some((32, 4032, 64, 3309)),
			87 => Some((32, 4896, 64, 4627)),
			_ => None,
		}
	}
	pub(crate) const fn mldsa_sign_workspace_bytes() -> usize {
		23552
	}
	pub(crate) const fn mldsa_prehash_bytes(algorithm: u32) -> Option<u64> {
		match algorithm {
			1 => Some(32),
			2 => Some(48),
			3 => Some(64),
			4 => Some(28),
			5 => Some(28),
			6 => Some(32),
			7 => Some(28),
			8 => Some(32),
			9 => Some(48),
			10 => Some(64),
			11 => Some(32),
			12 => Some(64),
			_ => None,
		}
	}
}

impl KernelId {
	pub(crate) const ALL: [Self; 365] = [
		Self::MatrixAddF32,
		Self::MatrixAddI32,
		Self::MatrixAddBroadcastF32,
		Self::MatrixAddBroadcastI32,
		Self::MatrixSubF32,
		Self::MatrixSubBroadcastF32,
		Self::MatrixMulF32,
		Self::MatrixMulBroadcastF32,
		Self::MatrixDivF32,
		Self::MatrixDivBroadcastF32,
		Self::MatrixScaleF32,
		Self::MatrixNegF32,
		Self::MatrixAbsF32,
		Self::MatrixLogF32,
		Self::MatrixSqrtF32,
		Self::MatrixPowF32,
		Self::MatrixAddScalarF32,
		Self::MatrixSubScalarF32,
		Self::MatrixDivScalarF32,
		Self::MatrixExpF32,
		Self::MatrixSinF32,
		Self::MatrixCosF32,
		Self::MatrixReciprocalF32,
		Self::MatrixClampMaxF32,
		Self::MatrixClampMinF32,
		Self::MatrixCopyF32,
		Self::MatrixCopyU8,
		Self::MatrixCopyI32,
		Self::MatrixCopyU32,
		Self::MatrixMatMulNtTiledF32,
		Self::MatrixSoftmaxF32,
		Self::MatrixSoftmaxBackwardF32,
		Self::MatrixLogSoftmaxF32,
		Self::MatrixLogSoftmaxBackwardF32,
		Self::MatrixSumF32,
		Self::MatrixSumAxisF32,
		Self::MatrixSumBackwardF32,
		Self::MatrixCategoricalAccuracyCountF32,
		Self::MatrixMaskedCategoricalAccuracyCountF32,
		Self::MatrixPhiloxUniformF32,
		Self::MatrixPhiloxNormalF32,
		Self::MatrixPhiloxUniformReplayF32,
		Self::MatrixPhiloxNormalReplayF32,
		Self::MatrixPhiloxReplayAdvanceU32,
		Self::MatrixDropoutF32,
		Self::MatrixDropoutBackwardF32,
		Self::MatrixSampleLogitsGreedyF32,
		Self::MatrixSampleLogitsDenseF32,
		Self::MatrixSampleLogitsSortedF32,
		Self::MatrixDropoutReplayF32,
		Self::MatrixDropoutBackwardReplayF32,
		Self::MatrixTopKF32,
		Self::MatrixTopKMaskF32,
		Self::MatrixMoeExpertPlanU32,
		Self::MatrixMoeRoutingBiasUpdateF32,
		Self::MatrixSliceF32,
		Self::MatrixSliceBackwardF32,
		Self::MatrixRepeatInterleaveF32,
		Self::MatrixRepeatInterleaveBackwardF32,
		Self::MatrixGatherF32,
		Self::MatrixGatherBackwardF32,
		Self::MatrixGatherLastDimF32,
		Self::MatrixGatherLastDimBackwardF32,
		Self::MatrixConcatF32,
		Self::MatrixTransposeF32,
		Self::MatrixEqualF32,
		Self::MlPpoClippedPolicyF32,
		Self::MlPpoClippedPolicyBackwardF32,
		Self::MlLinearF32,
		Self::MlLinearBackwardF32,
		Self::MlLinearParameterBackwardF32,
		Self::MlCrossEntropyF32,
		Self::MlCrossEntropySumF32,
		Self::MlCrossEntropyBackwardF32,
		Self::MlMaskedCrossEntropyF32,
		Self::MlMaskedCrossEntropyBackwardF32,
		Self::MlSmoothL1F32,
		Self::MlSmoothL1BackwardF32,
		Self::MlSmoothL1MeanF32,
		Self::MlMseF32,
		Self::MlMseBackwardF32,
		Self::MlL1F32,
		Self::MlL1BackwardF32,
		Self::MlBceF32,
		Self::MlBceBackwardF32,
		Self::MlSgdF32,
		Self::MlClipGradNormReduceF32,
		Self::MlClipGradNormScaleF32,
		Self::MlSgdMomentumF32,
		Self::MlAdamF32,
		Self::MlMuonNesterovF32,
		Self::MlMuonVectorF32,
		Self::MlMuonNormalizeF32,
		Self::MlMuonMatMulAxpbyF32,
		Self::MlMuonLinearCombinationF32,
		Self::MlMuonTransposeF32,
		Self::MlMuonApplyF32,
		Self::MlAdamWF32,
		Self::MlAdamWGraphAdvanceU32,
		Self::MlAdamWGraphF32,
		Self::MlEmbeddingF32,
		Self::MlEmbeddingBackwardF32,
		Self::MlChannelNormF32,
		Self::MlChannelNormBackwardF32,
		Self::MlChannelNormReluF32,
		Self::MlChannelNormReluBackwardF32,
		Self::MlEmbeddingU8F32,
		Self::MlEmbeddingBackwardU8F32,
		Self::MlRnnScanF32,
		Self::MlRnnScanBackwardF32,
		Self::MlLayerNormF32,
		Self::MlLayerNormBackwardF32,
		Self::MlRmsNormF32,
		Self::MlRmsNormBackwardF32,
		Self::MlGeluF32,
		Self::MlGeluBackwardF32,
		Self::MlSiluF32,
		Self::MlSiluBackwardF32,
		Self::MlReluF32,
		Self::MlReluBackwardF32,
		Self::MlTanhF32,
		Self::MlTanhBackwardF32,
		Self::MlSigmoidF32,
		Self::MlSigmoidBackwardF32,
		Self::MlLeakyReluF32,
		Self::MlLeakyReluBackwardF32,
		Self::MlEluF32,
		Self::MlEluBackwardF32,
		Self::MlMishF32,
		Self::MlMishBackwardF32,
		Self::MlSoftplusF32,
		Self::MlSoftplusBackwardF32,
		Self::MlQkvProjectionBiasF32,
		Self::MlSwigluF32,
		Self::MlSwigluBackwardF32,
		Self::MlGateUpSwigluBiasF32,
		Self::MlAdamWMany4F32,
		Self::MlAdamWMany4GraphF32,
		Self::MlRopeF32,
		Self::MlRopeBackwardF32,
		Self::MlAvgPool2dF32,
		Self::MlAvgPool2dBackwardF32,
		Self::MlMaxPool2dF32,
		Self::MlMaxPool2dBackwardF32,
		Self::MlAdaptiveAvgPool2dF32,
		Self::MlAdaptiveAvgPool2dBackwardF32,
		Self::MlBatchNorm2dF32,
		Self::MlBatchNorm2dWithStatsF32,
		Self::MlBatchNorm2dRunningUpdateF32,
		Self::MlBatchNorm2dBackwardF32,
		Self::MlBatchNorm2dInputBackwardF32,
		Self::MlUpsample2dNearestF32,
		Self::MlUpsample2dBilinearF32,
		Self::MlUpsample2dNearestBackwardF32,
		Self::MlUpsample2dBilinearBackwardF32,
		Self::MlConv2dF32,
		Self::MlConv2dBackwardF32,
		Self::MlConv2dParameterBackwardF32,
		Self::MlConv1dIm2ColF32,
		Self::MlConv1dBiasAddF32,
		Self::MlConv1dTransposeF32,
		Self::MlConv1dBackwardF32,
		Self::MlConv1dParameterBackwardF32,
		Self::MlConvTranspose1dF32,
		Self::MlConvTranspose1dBackwardF32,
		Self::MlConvTranspose2dF32,
		Self::MlConvTranspose2dBiasAddF32,
		Self::MlConvTranspose2dBackwardF32,
		Self::MlConvTranspose2dParameterBackwardF32,
		Self::MlGruScanF32,
		Self::MlGruScanBackwardF32,
		Self::MlGruCellF32,
		Self::MlGruCellBackwardF32,
		Self::MlRnnCellF32,
		Self::MlRnnCellBackwardF32,
		Self::MlBmmF32,
		Self::MlBmmTiled16F32,
		Self::MlBmmNtF32,
		Self::MlBmmNtTiled16F32,
		Self::MlBmmTnF32,
		Self::MlBmmTnTiled16F32,
		Self::MlSplitHeadsF32,
		Self::MlMergeHeadsF32,
		Self::MlSoftmaxScaledMaskedF32,
		Self::MlSoftmaxScaledMaskedN32F32,
		Self::MlSoftmaxScaledMaskedBackwardF32,
		Self::MlSdpaSoftmaxF32,
		Self::MlSdpaSoftmaxN32F32,
		Self::MlFlashAttentionCausalF32,
		Self::MlFlashAttentionCausalBackwardQF32,
		Self::MlFlashAttentionCausalBackwardKvF32,
		Self::MlMoeRouteWeightsF32,
		Self::MlMoeRouteWeightsBackwardF32,
		Self::MlMoeGatherF32,
		Self::MlMoeGatherBackwardF32,
		Self::MlMoeCombineF32,
		Self::MlMoeCombineBackwardF32,
		Self::MlGroupedLinearMF32,
		Self::MlGroupedLinearMDataBackwardF32,
		Self::MlGroupedLinearMParameterBackwardF32,
		Self::MlSiluMulF32,
		Self::MlSiluMulBackwardF32,
		Self::MlGroupedGemmMF32,
		Self::MlGroupedGemmMDataBackwardF32,
		Self::MlGroupedGemmMParameterBackwardF32,
		Self::MlFlowLinearMatchF32,
		Self::MlFlowEulerStepF32,
		Self::MlFlowMaskedMseF32,
		Self::MlFlowMaskedMseBackwardF32,
		Self::MlGaeF32,
		Self::MlRolloutAppendF32,
		Self::MlRolloutResetU8,
		Self::MlReplayAppendBatchF32,
		Self::MlReplaySampleF32,
		Self::MlDqnTargetF32,
		Self::MlSacTargetF32,
		Self::MlCartPoleResetF32,
		Self::MlCartPoleStepF32,
		Self::MlLunarLanderResetF32,
		Self::MlLunarLanderStepF32,
		Self::MlRmsNormGatedF32,
		Self::MlRmsNormGatedBackwardF32,
		Self::MlMamba3PreprocessF32,
		Self::MlMamba3PreprocessBackwardF32,
		Self::MlMamba3PreprocessBackwardReduceF32,
		Self::MlMamba3SisoF32,
		Self::MlMamba3SisoBackwardPrepareF32,
		Self::MlMamba3SisoStepF32,
		Self::MlMamba3SisoBackwardStateF32,
		Self::MlMamba3SisoBackwardReverseP16F32,
		Self::MlMamba3SisoBackwardFinalizeF32,
		Self::MlMamba3SisoBackwardReduceF32,
		Self::MlMamba3SisoBackwardGroupReduceF32,
		Self::MlMamba3MimoF32,
		Self::MlMamba3MimoBackwardCoreF32,
		Self::MlMamba3MimoStepF32,
		Self::MlMamba3MimoBackwardPrepareF32,
		Self::MlMamba3MimoBackwardPostF32,
		Self::MlMamba3MimoBackwardRotateF32,
		Self::MlMamba3MimoBackwardReduceF32,
		Self::MlMamba3SisoBackwardGenericF32,
		Self::MlMamba3SisoBackwardGenericReduceF32,
		Self::MlMamba3SisoChunkSummaryF32,
		Self::MlMamba3SisoChunkPrefixF32,
		Self::MlMamba3SisoChunkDpreF32,
		Self::MlMamba3SisoChunkBackwardSummaryF32,
		Self::MlMamba3SisoChunkBackwardPrefixF32,
		Self::MlMamba3SisoChunkBackwardF32,
		Self::MlMamba3SisoChunkFinalizeF32,
		Self::MlMamba3SisoChunkReduceF32,
		Self::MlVqAssignF32,
		Self::MlVqLookupF32,
		Self::MlVqEmaUpdateF32,
		Self::AudioGainF32,
		Self::AudioClipF32,
		Self::AudioSaturateF32,
		Self::AudioResampleF32,
		Self::AudioFadeF32,
		Self::AudioMixF32,
		Self::AudioAmplitudeToDbF32,
		Self::AudioWaveformEnvelopeF32,
		Self::AudioPreEmphasisF32,
		Self::AudioToMonoF32,
		Self::AudioNormalizeLevelF32,
		Self::AudioNormalizeApplyF32,
		Self::AudioBiquadSummaryF32,
		Self::AudioBiquadScanF32,
		Self::AudioBiquadApplyF32,
		Self::AudioReverbCombF32,
		Self::AudioReverbSumF32,
		Self::AudioReverbAllpassF32,
		Self::AudioReverbMixF32,
		Self::AudioStftF32,
		Self::AudioMelFilterbankF32,
		Self::AudioMelNormalizeF32,
		Self::AudioMfccDctF32,
		Self::AudioSosFilterF32,
		Self::CryptographyShake128U8,
		Self::CryptographyShake256U8,
		Self::CryptographyKeccakF1600U8,
		Self::CryptographyMerkleReduceU8,
		Self::CryptographyMerkleCopyU8,
		Self::CryptographyMlDsa65VerifyU8,
		Self::CryptographyMlDsa44VerifyU8,
		Self::CryptographyMlDsa87VerifyU8,
		Self::CryptographyMlDsa65VerifyPrehashedU8,
		Self::CryptographyMlDsa44VerifyPrehashedU8,
		Self::CryptographyMlDsa87VerifyPrehashedU8,
		Self::CryptographyMlDsa65VerifyHashMessageU8,
		Self::CryptographyMlDsa44VerifyHashMessageU8,
		Self::CryptographyMlDsa87VerifyHashMessageU8,
		Self::CryptographyMlKemKeygenU8,
		Self::CryptographyMlKemEncapsU8,
		Self::CryptographyMlKemDecapsU8,
		Self::CryptographyMlDsaKeygenU8,
		Self::CryptographyMlDsaSignU8,
		Self::CryptographyMlDsaSignMessageU8,
		Self::CryptographyMlDsaSignPrehashedU8,
		Self::CryptographyMlDsaSignHashMessageU8,
		Self::ImageResizeNearestF32,
		Self::ImageResizeBilinearF32,
		Self::ImageCropF32,
		Self::ImageFlipF32,
		Self::ImageRotateF32,
		Self::ImagePadF32,
		Self::ImageCenterCropF32,
		Self::ImageRemapF32,
		Self::ImageWarpAffineF32,
		Self::ImageWarpPerspectiveF32,
		Self::ImageThresholdBinaryF32,
		Self::ImageThresholdBinaryInvF32,
		Self::ImageThresholdTruncateF32,
		Self::ImageThresholdToZeroF32,
		Self::ImageThresholdToZeroInvF32,
		Self::ImageInRangeF32,
		Self::ImageClampF32,
		Self::ImageInvertF32,
		Self::ImageBrightnessContrastF32,
		Self::ImageGammaContrastF32,
		Self::ImageSolarizeF32,
		Self::ImagePosterizeF32,
		Self::ImageGrayscaleF32,
		Self::ImageAlphaBlendF32,
		Self::ImageCompositeF32,
		Self::ImageEraseF32,
		Self::ImageColorTwistF32,
		Self::ImageChannelReorderF32,
		Self::ImageGaussianNoiseF32,
		Self::ImageSaltPepperNoiseF32,
		Self::ImageConvolve2dF32,
		Self::ImageSeparableConvolve2dF32,
		Self::ImageAverageBlurF32,
		Self::ImageSobelF32,
		Self::ImageScharrF32,
		Self::ImageLaplacianF32,
		Self::ImageErodeF32,
		Self::ImageDilateF32,
		Self::ImageMorphologyOpenF32,
		Self::ImageMorphologyCloseF32,
		Self::ImageMorphologyGradientF32,
		Self::ImageGaussianBlurF32,
		Self::ImageSharpenF32,
		Self::ImageMedianBlurF32,
		Self::ImageBilateralFilterF32,
		Self::ImageUnsharpMaskF32,
		Self::ImageMorphologyTopHatF32,
		Self::ImageMorphologyBlackHatF32,
		Self::ImageAdaptiveThresholdMeanF32,
		Self::ImageAdaptiveThresholdGaussianF32,
		Self::ImageNormalizeF32,
		Self::ImageConvertColorF32,
		Self::ImageResizeNormalizeF32,
		Self::ImageSegmentationOverlayF32,
		Self::VisionBoxIouF32,
		Self::VisionNmsF32,
		Self::VisionConfusionMatrixI32,
		Self::VisionBinaryMaskCountsU8,
		Self::VisionDetectionMetricCurvesF32,
		Self::VisionDetectionAveragePrecisionF32,
		Self::VisionDetectionMeanAveragePrecisionF32,
		Self::VisionSegmentationConfusionI32,
		Self::VisionSegmentationMetricsF32,
		Self::VisionConfusionMatrixClearU32,
		Self::VisionBinaryMaskCountsClearU32,
		Self::VisionSegmentationConfusionClearU32,
	];

	pub(crate) const fn artifact(self) -> &'static ShaderArtifact {
		match self {
			Self::MatrixAddF32 => &MATRIX_ADD_F32,
			Self::MatrixAddI32 => &MATRIX_ADD_I32,
			Self::MatrixAddBroadcastF32 => &MATRIX_ADD_BROADCAST_F32,
			Self::MatrixAddBroadcastI32 => &MATRIX_ADD_BROADCAST_I32_I32,
			Self::MatrixSubF32 => &MATRIX_SUB_F32,
			Self::MatrixSubBroadcastF32 => &MATRIX_SUB_BROADCAST_F32,
			Self::MatrixMulF32 => &MATRIX_MUL_F32,
			Self::MatrixMulBroadcastF32 => &MATRIX_MUL_BROADCAST_F32,
			Self::MatrixDivF32 => &MATRIX_DIV_F32,
			Self::MatrixDivBroadcastF32 => &MATRIX_DIV_BROADCAST_F32,
			Self::MatrixScaleF32 => &MATRIX_SCALE_F32,
			Self::MatrixNegF32 => &MATRIX_NEG_F32,
			Self::MatrixAbsF32 => &MATRIX_ABS_F32,
			Self::MatrixLogF32 => &MATRIX_LOG_F32,
			Self::MatrixSqrtF32 => &MATRIX_SQRT_F32,
			Self::MatrixPowF32 => &MATRIX_POW_F32,
			Self::MatrixAddScalarF32 => &MATRIX_ADD_SCALAR_F32,
			Self::MatrixSubScalarF32 => &MATRIX_SUB_SCALAR_F32,
			Self::MatrixDivScalarF32 => &MATRIX_DIV_SCALAR_F32,
			Self::MatrixExpF32 => &MATRIX_EXP_F32,
			Self::MatrixSinF32 => &MATRIX_SIN_F32,
			Self::MatrixCosF32 => &MATRIX_COS_F32,
			Self::MatrixReciprocalF32 => &MATRIX_RECIPROCAL_F32,
			Self::MatrixClampMaxF32 => &MATRIX_CLAMP_MAX_F32,
			Self::MatrixClampMinF32 => &MATRIX_CLAMP_MIN_F32,
			Self::MatrixCopyF32 => &MATRIX_COPY_F32,
			Self::MatrixCopyU8 => &MATRIX_COPY_U8,
			Self::MatrixCopyI32 => &MATRIX_COPY_I32,
			Self::MatrixCopyU32 => &MATRIX_COPY_U32,
			Self::MatrixMatMulNtTiledF32 => &MATRIX_MAT_MUL_NT_F32,
			Self::MatrixSoftmaxF32 => &MATRIX_SOFTMAX_F32,
			Self::MatrixSoftmaxBackwardF32 => &MATRIX_SOFTMAX_BACKWARD_F32,
			Self::MatrixLogSoftmaxF32 => &MATRIX_LOG_SOFTMAX_F32,
			Self::MatrixLogSoftmaxBackwardF32 => &MATRIX_LOG_SOFTMAX_BACKWARD_F32,
			Self::MatrixSumF32 => &MATRIX_SUM_F32,
			Self::MatrixSumAxisF32 => &MATRIX_SUM_AXIS_F32,
			Self::MatrixSumBackwardF32 => &MATRIX_SUM_BACKWARD_F32,
			Self::MatrixCategoricalAccuracyCountF32 => &MATRIX_CATEGORICAL_ACCURACY_COUNT_F32,
			Self::MatrixMaskedCategoricalAccuracyCountF32 => {
				&MATRIX_MASKED_CATEGORICAL_ACCURACY_COUNT_F32
			}
			Self::MatrixPhiloxUniformF32 => &MATRIX_PHILOX_UNIFORM_F32,
			Self::MatrixPhiloxNormalF32 => &MATRIX_PHILOX_NORMAL_F32,
			Self::MatrixPhiloxUniformReplayF32 => &MATRIX_PHILOX_UNIFORM_REPLAY_F32,
			Self::MatrixPhiloxNormalReplayF32 => &MATRIX_PHILOX_NORMAL_REPLAY_F32,
			Self::MatrixPhiloxReplayAdvanceU32 => &MATRIX_PHILOX_REPLAY_ADVANCE_U32,
			Self::MatrixDropoutF32 => &MATRIX_DROPOUT_F32,
			Self::MatrixDropoutBackwardF32 => &MATRIX_DROPOUT_BACKWARD_F32,
			Self::MatrixSampleLogitsGreedyF32 => &MATRIX_SAMPLE_LOGITS_F32,
			Self::MatrixSampleLogitsDenseF32 => &MATRIX_SAMPLE_LOGITS_DENSE_F32,
			Self::MatrixSampleLogitsSortedF32 => &MATRIX_SAMPLE_LOGITS_SORTED_F32,
			Self::MatrixDropoutReplayF32 => &MATRIX_DROPOUT_REPLAY_F32,
			Self::MatrixDropoutBackwardReplayF32 => &MATRIX_DROPOUT_BACKWARD_REPLAY_F32,
			Self::MatrixTopKF32 => &MATRIX_TOP_K_F32,
			Self::MatrixTopKMaskF32 => &MATRIX_TOP_K_MASK_F32,
			Self::MatrixMoeExpertPlanU32 => &MATRIX_MOE_EXPERT_PLAN_U32,
			Self::MatrixMoeRoutingBiasUpdateF32 => &MATRIX_MOE_ROUTING_BIAS_UPDATE_F32,
			Self::MatrixSliceF32 => &MATRIX_SLICE_F32,
			Self::MatrixSliceBackwardF32 => &MATRIX_SLICE_BACKWARD_F32,
			Self::MatrixRepeatInterleaveF32 => &MATRIX_REPEAT_INTERLEAVE_F32,
			Self::MatrixRepeatInterleaveBackwardF32 => &MATRIX_REPEAT_INTERLEAVE_BACKWARD_F32,
			Self::MatrixGatherF32 => &MATRIX_GATHER_F32,
			Self::MatrixGatherBackwardF32 => &MATRIX_GATHER_BACKWARD_F32,
			Self::MatrixGatherLastDimF32 => &MATRIX_GATHER_LAST_DIM_F32,
			Self::MatrixGatherLastDimBackwardF32 => &MATRIX_GATHER_LAST_DIM_BACKWARD_F32,
			Self::MatrixConcatF32 => &MATRIX_CONCAT_U32,
			Self::MatrixTransposeF32 => &MATRIX_TRANSPOSE_F32,
			Self::MatrixEqualF32 => &MATRIX_EQUAL_F32,
			Self::MlPpoClippedPolicyF32 => &ML_PPO_CLIPPED_POLICY_F32,
			Self::MlPpoClippedPolicyBackwardF32 => &ML_PPO_CLIPPED_POLICY_BACKWARD_F32,
			Self::MlLinearF32 => &ML_LINEAR_F32,
			Self::MlLinearBackwardF32 => &ML_LINEAR_BACKWARD_F32,
			Self::MlLinearParameterBackwardF32 => &ML_LINEAR_PARAMETER_BACKWARD_F32,
			Self::MlCrossEntropyF32 => &ML_CROSS_ENTROPY_F32,
			Self::MlCrossEntropySumF32 => &ML_CROSS_ENTROPY_SUM_F32,
			Self::MlCrossEntropyBackwardF32 => &ML_CROSS_ENTROPY_BACKWARD_F32,
			Self::MlMaskedCrossEntropyF32 => &ML_MASKED_CROSS_ENTROPY_F32,
			Self::MlMaskedCrossEntropyBackwardF32 => &ML_MASKED_CROSS_ENTROPY_BACKWARD_F32,
			Self::MlSmoothL1F32 => &ML_SMOOTH_L1_F32,
			Self::MlSmoothL1BackwardF32 => &ML_SMOOTH_L1_BACKWARD_F32,
			Self::MlSmoothL1MeanF32 => &ML_SMOOTH_L1_MEAN_F32,
			Self::MlMseF32 => &ML_MSE_F32,
			Self::MlMseBackwardF32 => &ML_MSE_BACKWARD_F32,
			Self::MlL1F32 => &ML_L1_F32,
			Self::MlL1BackwardF32 => &ML_L1_BACKWARD_F32,
			Self::MlBceF32 => &ML_BCE_F32,
			Self::MlBceBackwardF32 => &ML_BCE_BACKWARD_F32,
			Self::MlSgdF32 => &ML_SGD_F32,
			Self::MlClipGradNormReduceF32 => &ML_CLIP_GRAD_NORM_F32,
			Self::MlClipGradNormScaleF32 => &ML_CLIP_GRAD_NORM_SCALE_F32,
			Self::MlSgdMomentumF32 => &ML_SGD_MOMENTUM_F32,
			Self::MlAdamF32 => &ML_ADAM_F32,
			Self::MlMuonNesterovF32 => &ML_MUON_F32,
			Self::MlMuonVectorF32 => &ML_MUON_VECTOR_F32,
			Self::MlMuonNormalizeF32 => &ML_MUON_NORMALIZE_F32,
			Self::MlMuonMatMulAxpbyF32 => &ML_MUON_MAT_MUL_AXPBY_F32,
			Self::MlMuonLinearCombinationF32 => &ML_MUON_LINEAR_COMBINATION_F32,
			Self::MlMuonTransposeF32 => &ML_MUON_TRANSPOSE_F32,
			Self::MlMuonApplyF32 => &ML_MUON_APPLY_F32,
			Self::MlAdamWF32 => &ML_ADAMW_F32,
			Self::MlAdamWGraphAdvanceU32 => &ML_ADAMW_GRAPH_ADVANCE_U32,
			Self::MlAdamWGraphF32 => &ML_ADAMW_GRAPH_F32,
			Self::MlEmbeddingF32 => &ML_EMBEDDING_F32,
			Self::MlEmbeddingBackwardF32 => &ML_EMBEDDING_BACKWARD_F32,
			Self::MlChannelNormF32 => &ML_CHANNEL_NORM_F32,
			Self::MlChannelNormBackwardF32 => &ML_CHANNEL_NORM_BACKWARD_F32,
			Self::MlChannelNormReluF32 => &ML_CHANNEL_NORM_RELU_F32,
			Self::MlChannelNormReluBackwardF32 => &ML_CHANNEL_NORM_RELU_BACKWARD_F32,
			Self::MlEmbeddingU8F32 => &ML_EMBEDDING_U8_F32,
			Self::MlEmbeddingBackwardU8F32 => &ML_EMBEDDING_BACKWARD_U8_F32,
			Self::MlRnnScanF32 => &ML_RNN_SCAN_F32,
			Self::MlRnnScanBackwardF32 => &ML_RNN_SCAN_BACKWARD_F32,
			Self::MlLayerNormF32 => &ML_LAYER_NORM_F32,
			Self::MlLayerNormBackwardF32 => &ML_LAYER_NORM_BACKWARD_F32,
			Self::MlRmsNormF32 => &ML_RMS_NORM_F32,
			Self::MlRmsNormBackwardF32 => &ML_RMS_NORM_BACKWARD_F32,
			Self::MlGeluF32 => &ML_GELU_F32,
			Self::MlGeluBackwardF32 => &ML_GELU_BACKWARD_F32,
			Self::MlSiluF32 => &ML_SILU_F32,
			Self::MlSiluBackwardF32 => &ML_SILU_BACKWARD_F32,
			Self::MlReluF32 => &ML_RELU_F32,
			Self::MlReluBackwardF32 => &ML_RELU_BACKWARD_F32,
			Self::MlTanhF32 => &ML_TANH_F32,
			Self::MlTanhBackwardF32 => &ML_TANH_BACKWARD_F32,
			Self::MlSigmoidF32 => &ML_SIGMOID_F32,
			Self::MlSigmoidBackwardF32 => &ML_SIGMOID_BACKWARD_F32,
			Self::MlLeakyReluF32 => &ML_LEAKY_RELU_F32,
			Self::MlLeakyReluBackwardF32 => &ML_LEAKY_RELU_BACKWARD_F32,
			Self::MlEluF32 => &ML_ELU_F32,
			Self::MlEluBackwardF32 => &ML_ELU_BACKWARD_F32,
			Self::MlMishF32 => &ML_MISH_F32,
			Self::MlMishBackwardF32 => &ML_MISH_BACKWARD_F32,
			Self::MlSoftplusF32 => &ML_SOFTPLUS_F32,
			Self::MlSoftplusBackwardF32 => &ML_SOFTPLUS_BACKWARD_F32,
			Self::MlQkvProjectionBiasF32 => &ML_QKV_PROJECTION_BIAS_F32,
			Self::MlSwigluF32 => &ML_SWIGLU_F32,
			Self::MlSwigluBackwardF32 => &ML_SWIGLU_BACKWARD_F32,
			Self::MlGateUpSwigluBiasF32 => &ML_GATE_UP_SWIGLU_BIAS_F32,
			Self::MlAdamWMany4F32 => &ML_ADAMW_MANY4_F32,
			Self::MlAdamWMany4GraphF32 => &ML_ADAMW_MANY4_GRAPH_F32,
			Self::MlRopeF32 => &ML_ROPE_F32,
			Self::MlRopeBackwardF32 => &ML_ROPE_BACKWARD_F32,
			Self::MlAvgPool2dF32 => &ML_AVG_POOL_2D_F32,
			Self::MlAvgPool2dBackwardF32 => &ML_AVG_POOL_2D_BACKWARD_F32,
			Self::MlMaxPool2dF32 => &ML_MAX_POOL_2D_F32,
			Self::MlMaxPool2dBackwardF32 => &ML_MAX_POOL_2D_BACKWARD_F32,
			Self::MlAdaptiveAvgPool2dF32 => &ML_ADAPTIVE_AVG_POOL_2D_F32,
			Self::MlAdaptiveAvgPool2dBackwardF32 => &ML_ADAPTIVE_AVG_POOL_2D_BACKWARD_F32,
			Self::MlBatchNorm2dF32 => &ML_BATCH_NORM_2D_F32,
			Self::MlBatchNorm2dWithStatsF32 => &ML_BATCH_NORM_2D_WITH_STATS_F32,
			Self::MlBatchNorm2dRunningUpdateF32 => &ML_BATCH_NORM_2D_RUNNING_UPDATE_F32,
			Self::MlBatchNorm2dBackwardF32 => &ML_BATCH_NORM_2D_BACKWARD_F32,
			Self::MlBatchNorm2dInputBackwardF32 => &ML_BATCH_NORM_2D_INPUT_BACKWARD_F32,
			Self::MlUpsample2dNearestF32 => &ML_UPSAMPLE_2D_F32,
			Self::MlUpsample2dBilinearF32 => &ML_UPSAMPLE_2D_BILINEAR_F32,
			Self::MlUpsample2dNearestBackwardF32 => &ML_UPSAMPLE_2D_BACKWARD_F32,
			Self::MlUpsample2dBilinearBackwardF32 => &ML_UPSAMPLE_2D_BILINEAR_BACKWARD_F32,
			Self::MlConv2dF32 => &ML_CONV_2D_F32,
			Self::MlConv2dBackwardF32 => &ML_CONV_2D_BACKWARD_F32,
			Self::MlConv2dParameterBackwardF32 => &ML_CONV_2D_PARAMETER_BACKWARD_F32,
			Self::MlConv1dIm2ColF32 => &ML_CONV_1D_F32,
			Self::MlConv1dBiasAddF32 => &ML_CONV_1D_BIAS_ADD_F32,
			Self::MlConv1dTransposeF32 => &ML_CONV_1D_TRANSPOSE_F32,
			Self::MlConv1dBackwardF32 => &ML_CONV_1D_BACKWARD_F32,
			Self::MlConv1dParameterBackwardF32 => &ML_CONV_1D_PARAMETER_BACKWARD_F32,
			Self::MlConvTranspose1dF32 => &ML_CONV_TRANSPOSE_1D_F32,
			Self::MlConvTranspose1dBackwardF32 => &ML_CONV_TRANSPOSE_1D_BACKWARD_F32,
			Self::MlConvTranspose2dF32 => &ML_CONV_TRANSPOSE_2D_F32,
			Self::MlConvTranspose2dBiasAddF32 => &ML_CONV_TRANSPOSE_2D_BIAS_ADD_F32,
			Self::MlConvTranspose2dBackwardF32 => &ML_CONV_TRANSPOSE_2D_BACKWARD_F32,
			Self::MlConvTranspose2dParameterBackwardF32 => &ML_CONV_TRANSPOSE_2D_PARAMETER_BACKWARD_F32,
			Self::MlGruScanF32 => &ML_GRU_SCAN_F32,
			Self::MlGruScanBackwardF32 => &ML_GRU_SCAN_BACKWARD_F32,
			Self::MlGruCellF32 => &ML_GRU_CELL_F32,
			Self::MlGruCellBackwardF32 => &ML_GRU_CELL_BACKWARD_F32,
			Self::MlRnnCellF32 => &ML_RNN_CELL_F32,
			Self::MlRnnCellBackwardF32 => &ML_RNN_CELL_BACKWARD_F32,
			Self::MlBmmF32 => &ML_BMM_F32,
			Self::MlBmmTiled16F32 => &ML_BMM_TILED_16_F32,
			Self::MlBmmNtF32 => &ML_BMM_NT_F32,
			Self::MlBmmNtTiled16F32 => &ML_BMM_NT_TILED_16_F32,
			Self::MlBmmTnF32 => &ML_BMM_TN_F32,
			Self::MlBmmTnTiled16F32 => &ML_BMM_TN_TILED_16_F32,
			Self::MlSplitHeadsF32 => &ML_SPLIT_HEADS_F32,
			Self::MlMergeHeadsF32 => &ML_MERGE_HEADS_F32,
			Self::MlSoftmaxScaledMaskedF32 => &ML_SOFTMAX_SCALED_MASKED_F32,
			Self::MlSoftmaxScaledMaskedN32F32 => &ML_SOFTMAX_SCALED_MASKED_N32_F32,
			Self::MlSoftmaxScaledMaskedBackwardF32 => &ML_SOFTMAX_SCALED_MASKED_BACKWARD_F32,
			Self::MlSdpaSoftmaxF32 => &ML_SCALED_DOT_PRODUCT_ATTENTION_F32,
			Self::MlSdpaSoftmaxN32F32 => &ML_SDPA_SOFTMAX_N32_F32,
			Self::MlFlashAttentionCausalF32 => &ML_FLASH_ATTENTION_CAUSAL_F32,
			Self::MlFlashAttentionCausalBackwardQF32 => &ML_SCALED_DOT_PRODUCT_ATTENTION_BACKWARD_F32,
			Self::MlFlashAttentionCausalBackwardKvF32 => &ML_FLASH_ATTENTION_CAUSAL_BACKWARD_KV_F32,
			Self::MlMoeRouteWeightsF32 => &ML_MOE_ROUTE_WEIGHTS_F32,
			Self::MlMoeRouteWeightsBackwardF32 => &ML_MOE_ROUTE_WEIGHTS_BACKWARD_F32,
			Self::MlMoeGatherF32 => &ML_MOE_GATHER_F32,
			Self::MlMoeGatherBackwardF32 => &ML_MOE_GATHER_BACKWARD_F32,
			Self::MlMoeCombineF32 => &ML_MOE_COMBINE_F32,
			Self::MlMoeCombineBackwardF32 => &ML_MOE_COMBINE_BACKWARD_F32,
			Self::MlGroupedLinearMF32 => &ML_GROUPED_LINEAR_M_F32,
			Self::MlGroupedLinearMDataBackwardF32 => &ML_GROUPED_LINEAR_M_BACKWARD_F32,
			Self::MlGroupedLinearMParameterBackwardF32 => &ML_GROUPED_LINEAR_M_PARAMETER_BACKWARD_F32,
			Self::MlSiluMulF32 => &ML_SILU_MUL_F32,
			Self::MlSiluMulBackwardF32 => &ML_SILU_MUL_BACKWARD_F32,
			Self::MlGroupedGemmMF32 => &ML_GROUPED_GEMM_M_F32,
			Self::MlGroupedGemmMDataBackwardF32 => &ML_GROUPED_GEMM_M_BACKWARD_F32,
			Self::MlGroupedGemmMParameterBackwardF32 => &ML_GROUPED_GEMM_M_PARAMETER_BACKWARD_F32,
			Self::MlFlowLinearMatchF32 => &ML_LINEAR_MATCH_F32,
			Self::MlFlowEulerStepF32 => &ML_EULER_STEP_F32,
			Self::MlFlowMaskedMseF32 => &ML_MASKED_MSE_F32,
			Self::MlFlowMaskedMseBackwardF32 => &ML_MASKED_MSE_BACKWARD_F32,
			Self::MlGaeF32 => &ML_GAE_F32,
			Self::MlRolloutAppendF32 => &ML_APPEND_F32,
			Self::MlRolloutResetU8 => &ML_RESET_U8,
			Self::MlReplayAppendBatchF32 => &ML_APPEND_BATCH_F32,
			Self::MlReplaySampleF32 => &ML_SAMPLE_F32,
			Self::MlDqnTargetF32 => &ML_DQN_TARGET_F32,
			Self::MlSacTargetF32 => &ML_SAC_TARGET_F32,
			Self::MlCartPoleResetF32 => &ML_CART_POLE_RESET_F32,
			Self::MlCartPoleStepF32 => &ML_CART_POLE_STEP_F32,
			Self::MlLunarLanderResetF32 => &ML_LUNAR_LANDER_RESET_F32,
			Self::MlLunarLanderStepF32 => &ML_LUNAR_LANDER_STEP_F32,
			Self::MlRmsNormGatedF32 => &ML_RMS_NORM_GATED_F32,
			Self::MlRmsNormGatedBackwardF32 => &ML_RMS_NORM_GATED_BACKWARD_F32,
			Self::MlMamba3PreprocessF32 => &ML_MAMBA3_PREPROCESS_F32,
			Self::MlMamba3PreprocessBackwardF32 => &ML_MAMBA3_PREPROCESS_BACKWARD_F32,
			Self::MlMamba3PreprocessBackwardReduceF32 => &ML_MAMBA3_PREPROCESS_BACKWARD_REDUCE_F32,
			Self::MlMamba3SisoF32 => &ML_MAMBA3_SISO_F32,
			Self::MlMamba3SisoBackwardPrepareF32 => &ML_MAMBA3_SISO_BACKWARD_F32,
			Self::MlMamba3SisoStepF32 => &ML_MAMBA3_SISO_STEP_F32,
			Self::MlMamba3SisoBackwardStateF32 => &ML_MAMBA3_SISO_BACKWARD_STATE_F32,
			Self::MlMamba3SisoBackwardReverseP16F32 => &ML_MAMBA3_SISO_BACKWARD_REVERSE_P16_F32,
			Self::MlMamba3SisoBackwardFinalizeF32 => &ML_MAMBA3_SISO_BACKWARD_FINALIZE_F32,
			Self::MlMamba3SisoBackwardReduceF32 => &ML_MAMBA3_SISO_BACKWARD_REDUCE_F32,
			Self::MlMamba3SisoBackwardGroupReduceF32 => &ML_MAMBA3_SISO_BACKWARD_GROUP_REDUCE_F32,
			Self::MlMamba3MimoF32 => &ML_MAMBA3_MIMO_F32,
			Self::MlMamba3MimoBackwardCoreF32 => &ML_MAMBA3_MIMO_BACKWARD_F32,
			Self::MlMamba3MimoStepF32 => &ML_MAMBA3_MIMO_STEP_F32,
			Self::MlMamba3MimoBackwardPrepareF32 => &ML_MAMBA3_MIMO_BACKWARD_PREPARE_F32,
			Self::MlMamba3MimoBackwardPostF32 => &ML_MAMBA3_MIMO_BACKWARD_POST_F32,
			Self::MlMamba3MimoBackwardRotateF32 => &ML_MAMBA3_MIMO_BACKWARD_ROTATE_F32,
			Self::MlMamba3MimoBackwardReduceF32 => &ML_MAMBA3_MIMO_BACKWARD_REDUCE_F32,
			Self::MlMamba3SisoBackwardGenericF32 => &ML_MAMBA3_SISO_BACKWARD_GENERIC_F32,
			Self::MlMamba3SisoBackwardGenericReduceF32 => &ML_MAMBA3_SISO_BACKWARD_GENERIC_REDUCE_F32,
			Self::MlMamba3SisoChunkSummaryF32 => &ML_MAMBA3_SISO_CHUNK_SUMMARY_F32,
			Self::MlMamba3SisoChunkPrefixF32 => &ML_MAMBA3_SISO_CHUNK_PREFIX_F32,
			Self::MlMamba3SisoChunkDpreF32 => &ML_MAMBA3_SISO_CHUNK_DPRE_F32,
			Self::MlMamba3SisoChunkBackwardSummaryF32 => &ML_MAMBA3_SISO_CHUNK_BACKWARD_SUMMARY_F32,
			Self::MlMamba3SisoChunkBackwardPrefixF32 => &ML_MAMBA3_SISO_CHUNK_BACKWARD_PREFIX_F32,
			Self::MlMamba3SisoChunkBackwardF32 => &ML_MAMBA3_SISO_CHUNK_BACKWARD_F32,
			Self::MlMamba3SisoChunkFinalizeF32 => &ML_MAMBA3_SISO_CHUNK_FINALIZE_F32,
			Self::MlMamba3SisoChunkReduceF32 => &ML_MAMBA3_SISO_CHUNK_REDUCE_F32,
			Self::MlVqAssignF32 => &ML_VQ_ASSIGN_F32,
			Self::MlVqLookupF32 => &ML_VQ_LOOKUP_F32,
			Self::MlVqEmaUpdateF32 => &ML_VQ_EMA_UPDATE_F32,
			Self::AudioGainF32 => &AUDIO_GAIN_F32,
			Self::AudioClipF32 => &AUDIO_CLIP_F32,
			Self::AudioSaturateF32 => &AUDIO_SATURATE_F32,
			Self::AudioResampleF32 => &AUDIO_RESAMPLE_F32,
			Self::AudioFadeF32 => &AUDIO_FADE_F32,
			Self::AudioMixF32 => &AUDIO_MIX_F32,
			Self::AudioAmplitudeToDbF32 => &AUDIO_AMPLITUDE_TO_DB_F32,
			Self::AudioWaveformEnvelopeF32 => &AUDIO_WAVEFORM_ENVELOPE_F32,
			Self::AudioPreEmphasisF32 => &AUDIO_PRE_EMPHASIS_F32,
			Self::AudioToMonoF32 => &AUDIO_TO_MONO_F32,
			Self::AudioNormalizeLevelF32 => &AUDIO_NORMALIZE_LEVEL_F32,
			Self::AudioNormalizeApplyF32 => &AUDIO_NORMALIZE_APPLY_F32,
			Self::AudioBiquadSummaryF32 => &AUDIO_BIQUAD_SUMMARY_F32,
			Self::AudioBiquadScanF32 => &AUDIO_BIQUAD_SCAN_F32,
			Self::AudioBiquadApplyF32 => &AUDIO_BIQUAD_APPLY_F32,
			Self::AudioReverbCombF32 => &AUDIO_REVERB_COMB_F32,
			Self::AudioReverbSumF32 => &AUDIO_REVERB_SUM_F32,
			Self::AudioReverbAllpassF32 => &AUDIO_REVERB_ALLPASS_F32,
			Self::AudioReverbMixF32 => &AUDIO_REVERB_MIX_F32,
			Self::AudioStftF32 => &AUDIO_STFT_F32,
			Self::AudioMelFilterbankF32 => &AUDIO_MEL_FILTERBANK_F32,
			Self::AudioMelNormalizeF32 => &AUDIO_MEL_NORMALIZE_F32,
			Self::AudioMfccDctF32 => &AUDIO_MFCC_DCT_F32,
			Self::AudioSosFilterF32 => &AUDIO_SOS_FILTER_F32,
			Self::CryptographyShake128U8 => &CRYPTOGRAPHY_SHAKE128_U8,
			Self::CryptographyShake256U8 => &CRYPTOGRAPHY_SHAKE256_U8,
			Self::CryptographyKeccakF1600U8 => &CRYPTOGRAPHY_KECCAK_F1600_U8,
			Self::CryptographyMerkleReduceU8 => &CRYPTOGRAPHY_MERKLE_REDUCE_U8,
			Self::CryptographyMerkleCopyU8 => &CRYPTOGRAPHY_MERKLE_COPY_U8,
			Self::CryptographyMlDsa65VerifyU8 => &CRYPTOGRAPHY_ML_DSA_65_VERIFY_U8,
			Self::CryptographyMlDsa44VerifyU8 => &CRYPTOGRAPHY_ML_DSA_44_VERIFY_U8,
			Self::CryptographyMlDsa87VerifyU8 => &CRYPTOGRAPHY_ML_DSA_87_VERIFY_U8,
			Self::CryptographyMlDsa65VerifyPrehashedU8 => &CRYPTOGRAPHY_ML_DSA_65_VERIFY_PREHASHED_U8,
			Self::CryptographyMlDsa44VerifyPrehashedU8 => &CRYPTOGRAPHY_ML_DSA_44_VERIFY_PREHASHED_U8,
			Self::CryptographyMlDsa87VerifyPrehashedU8 => &CRYPTOGRAPHY_ML_DSA_87_VERIFY_PREHASHED_U8,
			Self::CryptographyMlDsa65VerifyHashMessageU8 => {
				&CRYPTOGRAPHY_ML_DSA_65_VERIFY_HASH_MESSAGE_U8
			}
			Self::CryptographyMlDsa44VerifyHashMessageU8 => {
				&CRYPTOGRAPHY_ML_DSA_44_VERIFY_HASH_MESSAGE_U8
			}
			Self::CryptographyMlDsa87VerifyHashMessageU8 => {
				&CRYPTOGRAPHY_ML_DSA_87_VERIFY_HASH_MESSAGE_U8
			}
			Self::CryptographyMlKemKeygenU8 => &CRYPTOGRAPHY_ML_KEM_KEYGEN_U8,
			Self::CryptographyMlKemEncapsU8 => &CRYPTOGRAPHY_ML_KEM_ENCAPS_U8,
			Self::CryptographyMlKemDecapsU8 => &CRYPTOGRAPHY_ML_KEM_DECAPS_U8,
			Self::CryptographyMlDsaKeygenU8 => &CRYPTOGRAPHY_ML_DSA_KEYGEN_U8,
			Self::CryptographyMlDsaSignU8 => &CRYPTOGRAPHY_ML_DSA_SIGN_U8,
			Self::CryptographyMlDsaSignMessageU8 => &CRYPTOGRAPHY_ML_DSA_SIGN_MESSAGE_U8,
			Self::CryptographyMlDsaSignPrehashedU8 => &CRYPTOGRAPHY_ML_DSA_SIGN_PREHASHED_U8,
			Self::CryptographyMlDsaSignHashMessageU8 => &CRYPTOGRAPHY_ML_DSA_SIGN_HASH_MESSAGE_U8,
			Self::ImageResizeNearestF32 => &IMAGE_RESIZE_NEAREST_F32,
			Self::ImageResizeBilinearF32 => &IMAGE_RESIZE_BILINEAR_F32,
			Self::ImageCropF32 => &IMAGE_CROP_F32,
			Self::ImageFlipF32 => &IMAGE_FLIP_F32,
			Self::ImageRotateF32 => &IMAGE_ROTATE_F32,
			Self::ImagePadF32 => &IMAGE_PAD_F32,
			Self::ImageCenterCropF32 => &IMAGE_CENTER_CROP_F32,
			Self::ImageRemapF32 => &IMAGE_REMAP_F32,
			Self::ImageWarpAffineF32 => &IMAGE_WARP_AFFINE_F32,
			Self::ImageWarpPerspectiveF32 => &IMAGE_WARP_PERSPECTIVE_F32,
			Self::ImageThresholdBinaryF32 => &IMAGE_THRESHOLD_BINARY_F32,
			Self::ImageThresholdBinaryInvF32 => &IMAGE_THRESHOLD_BINARY_INV_F32,
			Self::ImageThresholdTruncateF32 => &IMAGE_THRESHOLD_TRUNCATE_F32,
			Self::ImageThresholdToZeroF32 => &IMAGE_THRESHOLD_TO_ZERO_F32,
			Self::ImageThresholdToZeroInvF32 => &IMAGE_THRESHOLD_TO_ZERO_INV_F32,
			Self::ImageInRangeF32 => &IMAGE_IN_RANGE_F32,
			Self::ImageClampF32 => &IMAGE_CLAMP_F32,
			Self::ImageInvertF32 => &IMAGE_INVERT_F32,
			Self::ImageBrightnessContrastF32 => &IMAGE_BRIGHTNESS_CONTRAST_F32,
			Self::ImageGammaContrastF32 => &IMAGE_GAMMA_CONTRAST_F32,
			Self::ImageSolarizeF32 => &IMAGE_SOLARIZE_F32,
			Self::ImagePosterizeF32 => &IMAGE_POSTERIZE_F32,
			Self::ImageGrayscaleF32 => &IMAGE_GRAYSCALE_F32,
			Self::ImageAlphaBlendF32 => &IMAGE_ALPHA_BLEND_F32,
			Self::ImageCompositeF32 => &IMAGE_COMPOSITE_F32,
			Self::ImageEraseF32 => &IMAGE_ERASE_F32,
			Self::ImageColorTwistF32 => &IMAGE_COLOR_TWIST_F32,
			Self::ImageChannelReorderF32 => &IMAGE_CHANNEL_REORDER_F32,
			Self::ImageGaussianNoiseF32 => &IMAGE_GAUSSIAN_NOISE_F32,
			Self::ImageSaltPepperNoiseF32 => &IMAGE_SALT_PEPPER_NOISE_F32,
			Self::ImageConvolve2dF32 => &IMAGE_CONVOLVE_2D_F32,
			Self::ImageSeparableConvolve2dF32 => &IMAGE_SEPARABLE_CONVOLVE_2D_F32,
			Self::ImageAverageBlurF32 => &IMAGE_AVERAGE_BLUR_F32,
			Self::ImageSobelF32 => &IMAGE_SOBEL_F32,
			Self::ImageScharrF32 => &IMAGE_SCHARR_F32,
			Self::ImageLaplacianF32 => &IMAGE_LAPLACIAN_F32,
			Self::ImageErodeF32 => &IMAGE_ERODE_F32,
			Self::ImageDilateF32 => &IMAGE_DILATE_F32,
			Self::ImageMorphologyOpenF32 => &IMAGE_MORPHOLOGY_OPEN_F32,
			Self::ImageMorphologyCloseF32 => &IMAGE_MORPHOLOGY_CLOSE_F32,
			Self::ImageMorphologyGradientF32 => &IMAGE_MORPHOLOGY_GRADIENT_F32,
			Self::ImageGaussianBlurF32 => &IMAGE_GAUSSIAN_BLUR_F32,
			Self::ImageSharpenF32 => &IMAGE_SHARPEN_F32,
			Self::ImageMedianBlurF32 => &IMAGE_MEDIAN_BLUR_F32,
			Self::ImageBilateralFilterF32 => &IMAGE_BILATERAL_FILTER_F32,
			Self::ImageUnsharpMaskF32 => &IMAGE_UNSHARP_MASK_F32,
			Self::ImageMorphologyTopHatF32 => &IMAGE_MORPHOLOGY_TOP_HAT_F32,
			Self::ImageMorphologyBlackHatF32 => &IMAGE_MORPHOLOGY_BLACK_HAT_F32,
			Self::ImageAdaptiveThresholdMeanF32 => &IMAGE_ADAPTIVE_THRESHOLD_MEAN_F32,
			Self::ImageAdaptiveThresholdGaussianF32 => &IMAGE_ADAPTIVE_THRESHOLD_GAUSSIAN_F32,
			Self::ImageNormalizeF32 => &IMAGE_NORMALIZE_F32,
			Self::ImageConvertColorF32 => &IMAGE_CONVERT_COLOR_F32,
			Self::ImageResizeNormalizeF32 => &IMAGE_RESIZE_NORMALIZE_F32,
			Self::ImageSegmentationOverlayF32 => &IMAGE_SEGMENTATION_OVERLAY_F32,
			Self::VisionBoxIouF32 => &VISION_BOX_IOU_F32,
			Self::VisionNmsF32 => &VISION_NMS_F32,
			Self::VisionConfusionMatrixI32 => &VISION_CONFUSION_MATRIX_I32,
			Self::VisionBinaryMaskCountsU8 => &VISION_BINARY_MASK_COUNTS_U8,
			Self::VisionDetectionMetricCurvesF32 => &VISION_DETECTION_METRIC_CURVES_F32,
			Self::VisionDetectionAveragePrecisionF32 => &VISION_DETECTION_AVERAGE_PRECISION_F32,
			Self::VisionDetectionMeanAveragePrecisionF32 => &VISION_DETECTION_MEAN_AVERAGE_PRECISION_F32,
			Self::VisionSegmentationConfusionI32 => &VISION_SEGMENTATION_CONFUSION_I32,
			Self::VisionSegmentationMetricsF32 => &VISION_SEGMENTATION_METRICS_F32,
			Self::VisionConfusionMatrixClearU32 => &VISION_CONFUSION_MATRIX_CLEAR_U32,
			Self::VisionBinaryMaskCountsClearU32 => &VISION_BINARY_MASK_COUNTS_CLEAR_U32,
			Self::VisionSegmentationConfusionClearU32 => &VISION_SEGMENTATION_CONFUSION_CLEAR_U32,
		}
	}

	pub(crate) const fn bounded_artifact(self) -> &'static ShaderArtifact {
		match self {
			Self::MatrixAddF32 => &BOUNDED_MATRIX_ADD_F32,
			Self::MatrixAddI32 => &BOUNDED_MATRIX_ADD_I32,
			Self::MatrixAddBroadcastF32 => &BOUNDED_MATRIX_ADD_BROADCAST_F32,
			Self::MatrixAddBroadcastI32 => &BOUNDED_MATRIX_ADD_BROADCAST_I32_I32,
			Self::MatrixSubF32 => &BOUNDED_MATRIX_SUB_F32,
			Self::MatrixSubBroadcastF32 => &BOUNDED_MATRIX_SUB_BROADCAST_F32,
			Self::MatrixMulF32 => &BOUNDED_MATRIX_MUL_F32,
			Self::MatrixMulBroadcastF32 => &BOUNDED_MATRIX_MUL_BROADCAST_F32,
			Self::MatrixDivF32 => &BOUNDED_MATRIX_DIV_F32,
			Self::MatrixDivBroadcastF32 => &BOUNDED_MATRIX_DIV_BROADCAST_F32,
			Self::MatrixScaleF32 => &BOUNDED_MATRIX_SCALE_F32,
			Self::MatrixNegF32 => &BOUNDED_MATRIX_NEG_F32,
			Self::MatrixAbsF32 => &BOUNDED_MATRIX_ABS_F32,
			Self::MatrixLogF32 => &BOUNDED_MATRIX_LOG_F32,
			Self::MatrixSqrtF32 => &BOUNDED_MATRIX_SQRT_F32,
			Self::MatrixPowF32 => &BOUNDED_MATRIX_POW_F32,
			Self::MatrixAddScalarF32 => &BOUNDED_MATRIX_ADD_SCALAR_F32,
			Self::MatrixSubScalarF32 => &BOUNDED_MATRIX_SUB_SCALAR_F32,
			Self::MatrixDivScalarF32 => &BOUNDED_MATRIX_DIV_SCALAR_F32,
			Self::MatrixExpF32 => &BOUNDED_MATRIX_EXP_F32,
			Self::MatrixSinF32 => &BOUNDED_MATRIX_SIN_F32,
			Self::MatrixCosF32 => &BOUNDED_MATRIX_COS_F32,
			Self::MatrixReciprocalF32 => &BOUNDED_MATRIX_RECIPROCAL_F32,
			Self::MatrixClampMaxF32 => &BOUNDED_MATRIX_CLAMP_MAX_F32,
			Self::MatrixClampMinF32 => &BOUNDED_MATRIX_CLAMP_MIN_F32,
			Self::MatrixCopyF32 => &BOUNDED_MATRIX_COPY_F32,
			Self::MatrixCopyU8 => &BOUNDED_MATRIX_COPY_U8,
			Self::MatrixCopyI32 => &BOUNDED_MATRIX_COPY_I32,
			Self::MatrixCopyU32 => &BOUNDED_MATRIX_COPY_U32,
			Self::MatrixMatMulNtTiledF32 => &BOUNDED_MATRIX_MAT_MUL_NT_F32,
			Self::MatrixSoftmaxF32 => &BOUNDED_MATRIX_SOFTMAX_F32,
			Self::MatrixSoftmaxBackwardF32 => &BOUNDED_MATRIX_SOFTMAX_BACKWARD_F32,
			Self::MatrixLogSoftmaxF32 => &BOUNDED_MATRIX_LOG_SOFTMAX_F32,
			Self::MatrixLogSoftmaxBackwardF32 => &BOUNDED_MATRIX_LOG_SOFTMAX_BACKWARD_F32,
			Self::MatrixSumF32 => &BOUNDED_MATRIX_SUM_F32,
			Self::MatrixSumAxisF32 => &BOUNDED_MATRIX_SUM_AXIS_F32,
			Self::MatrixSumBackwardF32 => &BOUNDED_MATRIX_SUM_BACKWARD_F32,
			Self::MatrixCategoricalAccuracyCountF32 => &BOUNDED_MATRIX_CATEGORICAL_ACCURACY_COUNT_F32,
			Self::MatrixMaskedCategoricalAccuracyCountF32 => {
				&BOUNDED_MATRIX_MASKED_CATEGORICAL_ACCURACY_COUNT_F32
			}
			Self::MatrixPhiloxUniformF32 => &BOUNDED_MATRIX_PHILOX_UNIFORM_F32,
			Self::MatrixPhiloxNormalF32 => &BOUNDED_MATRIX_PHILOX_NORMAL_F32,
			Self::MatrixPhiloxUniformReplayF32 => &BOUNDED_MATRIX_PHILOX_UNIFORM_REPLAY_F32,
			Self::MatrixPhiloxNormalReplayF32 => &BOUNDED_MATRIX_PHILOX_NORMAL_REPLAY_F32,
			Self::MatrixPhiloxReplayAdvanceU32 => &BOUNDED_MATRIX_PHILOX_REPLAY_ADVANCE_U32,
			Self::MatrixDropoutF32 => &BOUNDED_MATRIX_DROPOUT_F32,
			Self::MatrixDropoutBackwardF32 => &BOUNDED_MATRIX_DROPOUT_BACKWARD_F32,
			Self::MatrixSampleLogitsGreedyF32 => &BOUNDED_MATRIX_SAMPLE_LOGITS_F32,
			Self::MatrixSampleLogitsDenseF32 => &BOUNDED_MATRIX_SAMPLE_LOGITS_DENSE_F32,
			Self::MatrixSampleLogitsSortedF32 => &BOUNDED_MATRIX_SAMPLE_LOGITS_SORTED_F32,
			Self::MatrixDropoutReplayF32 => &BOUNDED_MATRIX_DROPOUT_REPLAY_F32,
			Self::MatrixDropoutBackwardReplayF32 => &BOUNDED_MATRIX_DROPOUT_BACKWARD_REPLAY_F32,
			Self::MatrixTopKF32 => &BOUNDED_MATRIX_TOP_K_F32,
			Self::MatrixTopKMaskF32 => &BOUNDED_MATRIX_TOP_K_MASK_F32,
			Self::MatrixMoeExpertPlanU32 => &BOUNDED_MATRIX_MOE_EXPERT_PLAN_U32,
			Self::MatrixMoeRoutingBiasUpdateF32 => &BOUNDED_MATRIX_MOE_ROUTING_BIAS_UPDATE_F32,
			Self::MatrixSliceF32 => &BOUNDED_MATRIX_SLICE_F32,
			Self::MatrixSliceBackwardF32 => &BOUNDED_MATRIX_SLICE_BACKWARD_F32,
			Self::MatrixRepeatInterleaveF32 => &BOUNDED_MATRIX_REPEAT_INTERLEAVE_F32,
			Self::MatrixRepeatInterleaveBackwardF32 => &BOUNDED_MATRIX_REPEAT_INTERLEAVE_BACKWARD_F32,
			Self::MatrixGatherF32 => &BOUNDED_MATRIX_GATHER_F32,
			Self::MatrixGatherBackwardF32 => &BOUNDED_MATRIX_GATHER_BACKWARD_F32,
			Self::MatrixGatherLastDimF32 => &BOUNDED_MATRIX_GATHER_LAST_DIM_F32,
			Self::MatrixGatherLastDimBackwardF32 => &BOUNDED_MATRIX_GATHER_LAST_DIM_BACKWARD_F32,
			Self::MatrixConcatF32 => &BOUNDED_MATRIX_CONCAT_U32,
			Self::MatrixTransposeF32 => &BOUNDED_MATRIX_TRANSPOSE_F32,
			Self::MatrixEqualF32 => &BOUNDED_MATRIX_EQUAL_F32,
			Self::MlPpoClippedPolicyF32 => &BOUNDED_ML_PPO_CLIPPED_POLICY_F32,
			Self::MlPpoClippedPolicyBackwardF32 => &BOUNDED_ML_PPO_CLIPPED_POLICY_BACKWARD_F32,
			Self::MlLinearF32 => &BOUNDED_ML_LINEAR_F32,
			Self::MlLinearBackwardF32 => &BOUNDED_ML_LINEAR_BACKWARD_F32,
			Self::MlLinearParameterBackwardF32 => &BOUNDED_ML_LINEAR_PARAMETER_BACKWARD_F32,
			Self::MlCrossEntropyF32 => &BOUNDED_ML_CROSS_ENTROPY_F32,
			Self::MlCrossEntropySumF32 => &BOUNDED_ML_CROSS_ENTROPY_SUM_F32,
			Self::MlCrossEntropyBackwardF32 => &BOUNDED_ML_CROSS_ENTROPY_BACKWARD_F32,
			Self::MlMaskedCrossEntropyF32 => &BOUNDED_ML_MASKED_CROSS_ENTROPY_F32,
			Self::MlMaskedCrossEntropyBackwardF32 => &BOUNDED_ML_MASKED_CROSS_ENTROPY_BACKWARD_F32,
			Self::MlSmoothL1F32 => &BOUNDED_ML_SMOOTH_L1_F32,
			Self::MlSmoothL1BackwardF32 => &BOUNDED_ML_SMOOTH_L1_BACKWARD_F32,
			Self::MlSmoothL1MeanF32 => &BOUNDED_ML_SMOOTH_L1_MEAN_F32,
			Self::MlMseF32 => &BOUNDED_ML_MSE_F32,
			Self::MlMseBackwardF32 => &BOUNDED_ML_MSE_BACKWARD_F32,
			Self::MlL1F32 => &BOUNDED_ML_L1_F32,
			Self::MlL1BackwardF32 => &BOUNDED_ML_L1_BACKWARD_F32,
			Self::MlBceF32 => &BOUNDED_ML_BCE_F32,
			Self::MlBceBackwardF32 => &BOUNDED_ML_BCE_BACKWARD_F32,
			Self::MlSgdF32 => &BOUNDED_ML_SGD_F32,
			Self::MlClipGradNormReduceF32 => &BOUNDED_ML_CLIP_GRAD_NORM_F32,
			Self::MlClipGradNormScaleF32 => &BOUNDED_ML_CLIP_GRAD_NORM_SCALE_F32,
			Self::MlSgdMomentumF32 => &BOUNDED_ML_SGD_MOMENTUM_F32,
			Self::MlAdamF32 => &BOUNDED_ML_ADAM_F32,
			Self::MlMuonNesterovF32 => &BOUNDED_ML_MUON_F32,
			Self::MlMuonVectorF32 => &BOUNDED_ML_MUON_VECTOR_F32,
			Self::MlMuonNormalizeF32 => &BOUNDED_ML_MUON_NORMALIZE_F32,
			Self::MlMuonMatMulAxpbyF32 => &BOUNDED_ML_MUON_MAT_MUL_AXPBY_F32,
			Self::MlMuonLinearCombinationF32 => &BOUNDED_ML_MUON_LINEAR_COMBINATION_F32,
			Self::MlMuonTransposeF32 => &BOUNDED_ML_MUON_TRANSPOSE_F32,
			Self::MlMuonApplyF32 => &BOUNDED_ML_MUON_APPLY_F32,
			Self::MlAdamWF32 => &BOUNDED_ML_ADAMW_F32,
			Self::MlAdamWGraphAdvanceU32 => &BOUNDED_ML_ADAMW_GRAPH_ADVANCE_U32,
			Self::MlAdamWGraphF32 => &BOUNDED_ML_ADAMW_GRAPH_F32,
			Self::MlEmbeddingF32 => &BOUNDED_ML_EMBEDDING_F32,
			Self::MlEmbeddingBackwardF32 => &BOUNDED_ML_EMBEDDING_BACKWARD_F32,
			Self::MlChannelNormF32 => &BOUNDED_ML_CHANNEL_NORM_F32,
			Self::MlChannelNormBackwardF32 => &BOUNDED_ML_CHANNEL_NORM_BACKWARD_F32,
			Self::MlChannelNormReluF32 => &BOUNDED_ML_CHANNEL_NORM_RELU_F32,
			Self::MlChannelNormReluBackwardF32 => &BOUNDED_ML_CHANNEL_NORM_RELU_BACKWARD_F32,
			Self::MlEmbeddingU8F32 => &BOUNDED_ML_EMBEDDING_U8_F32,
			Self::MlEmbeddingBackwardU8F32 => &BOUNDED_ML_EMBEDDING_BACKWARD_U8_F32,
			Self::MlRnnScanF32 => &BOUNDED_ML_RNN_SCAN_F32,
			Self::MlRnnScanBackwardF32 => &BOUNDED_ML_RNN_SCAN_BACKWARD_F32,
			Self::MlLayerNormF32 => &BOUNDED_ML_LAYER_NORM_F32,
			Self::MlLayerNormBackwardF32 => &BOUNDED_ML_LAYER_NORM_BACKWARD_F32,
			Self::MlRmsNormF32 => &BOUNDED_ML_RMS_NORM_F32,
			Self::MlRmsNormBackwardF32 => &BOUNDED_ML_RMS_NORM_BACKWARD_F32,
			Self::MlGeluF32 => &BOUNDED_ML_GELU_F32,
			Self::MlGeluBackwardF32 => &BOUNDED_ML_GELU_BACKWARD_F32,
			Self::MlSiluF32 => &BOUNDED_ML_SILU_F32,
			Self::MlSiluBackwardF32 => &BOUNDED_ML_SILU_BACKWARD_F32,
			Self::MlReluF32 => &BOUNDED_ML_RELU_F32,
			Self::MlReluBackwardF32 => &BOUNDED_ML_RELU_BACKWARD_F32,
			Self::MlTanhF32 => &BOUNDED_ML_TANH_F32,
			Self::MlTanhBackwardF32 => &BOUNDED_ML_TANH_BACKWARD_F32,
			Self::MlSigmoidF32 => &BOUNDED_ML_SIGMOID_F32,
			Self::MlSigmoidBackwardF32 => &BOUNDED_ML_SIGMOID_BACKWARD_F32,
			Self::MlLeakyReluF32 => &BOUNDED_ML_LEAKY_RELU_F32,
			Self::MlLeakyReluBackwardF32 => &BOUNDED_ML_LEAKY_RELU_BACKWARD_F32,
			Self::MlEluF32 => &BOUNDED_ML_ELU_F32,
			Self::MlEluBackwardF32 => &BOUNDED_ML_ELU_BACKWARD_F32,
			Self::MlMishF32 => &BOUNDED_ML_MISH_F32,
			Self::MlMishBackwardF32 => &BOUNDED_ML_MISH_BACKWARD_F32,
			Self::MlSoftplusF32 => &BOUNDED_ML_SOFTPLUS_F32,
			Self::MlSoftplusBackwardF32 => &BOUNDED_ML_SOFTPLUS_BACKWARD_F32,
			Self::MlQkvProjectionBiasF32 => &BOUNDED_ML_QKV_PROJECTION_BIAS_F32,
			Self::MlSwigluF32 => &BOUNDED_ML_SWIGLU_F32,
			Self::MlSwigluBackwardF32 => &BOUNDED_ML_SWIGLU_BACKWARD_F32,
			Self::MlGateUpSwigluBiasF32 => &BOUNDED_ML_GATE_UP_SWIGLU_BIAS_F32,
			Self::MlAdamWMany4F32 => &BOUNDED_ML_ADAMW_MANY4_F32,
			Self::MlAdamWMany4GraphF32 => &BOUNDED_ML_ADAMW_MANY4_GRAPH_F32,
			Self::MlRopeF32 => &BOUNDED_ML_ROPE_F32,
			Self::MlRopeBackwardF32 => &BOUNDED_ML_ROPE_BACKWARD_F32,
			Self::MlAvgPool2dF32 => &BOUNDED_ML_AVG_POOL_2D_F32,
			Self::MlAvgPool2dBackwardF32 => &BOUNDED_ML_AVG_POOL_2D_BACKWARD_F32,
			Self::MlMaxPool2dF32 => &BOUNDED_ML_MAX_POOL_2D_F32,
			Self::MlMaxPool2dBackwardF32 => &BOUNDED_ML_MAX_POOL_2D_BACKWARD_F32,
			Self::MlAdaptiveAvgPool2dF32 => &BOUNDED_ML_ADAPTIVE_AVG_POOL_2D_F32,
			Self::MlAdaptiveAvgPool2dBackwardF32 => &BOUNDED_ML_ADAPTIVE_AVG_POOL_2D_BACKWARD_F32,
			Self::MlBatchNorm2dF32 => &BOUNDED_ML_BATCH_NORM_2D_F32,
			Self::MlBatchNorm2dWithStatsF32 => &BOUNDED_ML_BATCH_NORM_2D_WITH_STATS_F32,
			Self::MlBatchNorm2dRunningUpdateF32 => &BOUNDED_ML_BATCH_NORM_2D_RUNNING_UPDATE_F32,
			Self::MlBatchNorm2dBackwardF32 => &BOUNDED_ML_BATCH_NORM_2D_BACKWARD_F32,
			Self::MlBatchNorm2dInputBackwardF32 => &BOUNDED_ML_BATCH_NORM_2D_INPUT_BACKWARD_F32,
			Self::MlUpsample2dNearestF32 => &BOUNDED_ML_UPSAMPLE_2D_F32,
			Self::MlUpsample2dBilinearF32 => &BOUNDED_ML_UPSAMPLE_2D_BILINEAR_F32,
			Self::MlUpsample2dNearestBackwardF32 => &BOUNDED_ML_UPSAMPLE_2D_BACKWARD_F32,
			Self::MlUpsample2dBilinearBackwardF32 => &BOUNDED_ML_UPSAMPLE_2D_BILINEAR_BACKWARD_F32,
			Self::MlConv2dF32 => &BOUNDED_ML_CONV_2D_F32,
			Self::MlConv2dBackwardF32 => &BOUNDED_ML_CONV_2D_BACKWARD_F32,
			Self::MlConv2dParameterBackwardF32 => &BOUNDED_ML_CONV_2D_PARAMETER_BACKWARD_F32,
			Self::MlConv1dIm2ColF32 => &BOUNDED_ML_CONV_1D_F32,
			Self::MlConv1dBiasAddF32 => &BOUNDED_ML_CONV_1D_BIAS_ADD_F32,
			Self::MlConv1dTransposeF32 => &BOUNDED_ML_CONV_1D_TRANSPOSE_F32,
			Self::MlConv1dBackwardF32 => &BOUNDED_ML_CONV_1D_BACKWARD_F32,
			Self::MlConv1dParameterBackwardF32 => &BOUNDED_ML_CONV_1D_PARAMETER_BACKWARD_F32,
			Self::MlConvTranspose1dF32 => &BOUNDED_ML_CONV_TRANSPOSE_1D_F32,
			Self::MlConvTranspose1dBackwardF32 => &BOUNDED_ML_CONV_TRANSPOSE_1D_BACKWARD_F32,
			Self::MlConvTranspose2dF32 => &BOUNDED_ML_CONV_TRANSPOSE_2D_F32,
			Self::MlConvTranspose2dBiasAddF32 => &BOUNDED_ML_CONV_TRANSPOSE_2D_BIAS_ADD_F32,
			Self::MlConvTranspose2dBackwardF32 => &BOUNDED_ML_CONV_TRANSPOSE_2D_BACKWARD_F32,
			Self::MlConvTranspose2dParameterBackwardF32 => {
				&BOUNDED_ML_CONV_TRANSPOSE_2D_PARAMETER_BACKWARD_F32
			}
			Self::MlGruScanF32 => &BOUNDED_ML_GRU_SCAN_F32,
			Self::MlGruScanBackwardF32 => &BOUNDED_ML_GRU_SCAN_BACKWARD_F32,
			Self::MlGruCellF32 => &BOUNDED_ML_GRU_CELL_F32,
			Self::MlGruCellBackwardF32 => &BOUNDED_ML_GRU_CELL_BACKWARD_F32,
			Self::MlRnnCellF32 => &BOUNDED_ML_RNN_CELL_F32,
			Self::MlRnnCellBackwardF32 => &BOUNDED_ML_RNN_CELL_BACKWARD_F32,
			Self::MlBmmF32 => &BOUNDED_ML_BMM_F32,
			Self::MlBmmTiled16F32 => &BOUNDED_ML_BMM_TILED_16_F32,
			Self::MlBmmNtF32 => &BOUNDED_ML_BMM_NT_F32,
			Self::MlBmmNtTiled16F32 => &BOUNDED_ML_BMM_NT_TILED_16_F32,
			Self::MlBmmTnF32 => &BOUNDED_ML_BMM_TN_F32,
			Self::MlBmmTnTiled16F32 => &BOUNDED_ML_BMM_TN_TILED_16_F32,
			Self::MlSplitHeadsF32 => &BOUNDED_ML_SPLIT_HEADS_F32,
			Self::MlMergeHeadsF32 => &BOUNDED_ML_MERGE_HEADS_F32,
			Self::MlSoftmaxScaledMaskedF32 => &BOUNDED_ML_SOFTMAX_SCALED_MASKED_F32,
			Self::MlSoftmaxScaledMaskedN32F32 => &BOUNDED_ML_SOFTMAX_SCALED_MASKED_N32_F32,
			Self::MlSoftmaxScaledMaskedBackwardF32 => &BOUNDED_ML_SOFTMAX_SCALED_MASKED_BACKWARD_F32,
			Self::MlSdpaSoftmaxF32 => &BOUNDED_ML_SCALED_DOT_PRODUCT_ATTENTION_F32,
			Self::MlSdpaSoftmaxN32F32 => &BOUNDED_ML_SDPA_SOFTMAX_N32_F32,
			Self::MlFlashAttentionCausalF32 => &BOUNDED_ML_FLASH_ATTENTION_CAUSAL_F32,
			Self::MlFlashAttentionCausalBackwardQF32 => {
				&BOUNDED_ML_SCALED_DOT_PRODUCT_ATTENTION_BACKWARD_F32
			}
			Self::MlFlashAttentionCausalBackwardKvF32 => {
				&BOUNDED_ML_FLASH_ATTENTION_CAUSAL_BACKWARD_KV_F32
			}
			Self::MlMoeRouteWeightsF32 => &BOUNDED_ML_MOE_ROUTE_WEIGHTS_F32,
			Self::MlMoeRouteWeightsBackwardF32 => &BOUNDED_ML_MOE_ROUTE_WEIGHTS_BACKWARD_F32,
			Self::MlMoeGatherF32 => &BOUNDED_ML_MOE_GATHER_F32,
			Self::MlMoeGatherBackwardF32 => &BOUNDED_ML_MOE_GATHER_BACKWARD_F32,
			Self::MlMoeCombineF32 => &BOUNDED_ML_MOE_COMBINE_F32,
			Self::MlMoeCombineBackwardF32 => &BOUNDED_ML_MOE_COMBINE_BACKWARD_F32,
			Self::MlGroupedLinearMF32 => &BOUNDED_ML_GROUPED_LINEAR_M_F32,
			Self::MlGroupedLinearMDataBackwardF32 => &BOUNDED_ML_GROUPED_LINEAR_M_BACKWARD_F32,
			Self::MlGroupedLinearMParameterBackwardF32 => {
				&BOUNDED_ML_GROUPED_LINEAR_M_PARAMETER_BACKWARD_F32
			}
			Self::MlSiluMulF32 => &BOUNDED_ML_SILU_MUL_F32,
			Self::MlSiluMulBackwardF32 => &BOUNDED_ML_SILU_MUL_BACKWARD_F32,
			Self::MlGroupedGemmMF32 => &BOUNDED_ML_GROUPED_GEMM_M_F32,
			Self::MlGroupedGemmMDataBackwardF32 => &BOUNDED_ML_GROUPED_GEMM_M_BACKWARD_F32,
			Self::MlGroupedGemmMParameterBackwardF32 => &BOUNDED_ML_GROUPED_GEMM_M_PARAMETER_BACKWARD_F32,
			Self::MlFlowLinearMatchF32 => &BOUNDED_ML_LINEAR_MATCH_F32,
			Self::MlFlowEulerStepF32 => &BOUNDED_ML_EULER_STEP_F32,
			Self::MlFlowMaskedMseF32 => &BOUNDED_ML_MASKED_MSE_F32,
			Self::MlFlowMaskedMseBackwardF32 => &BOUNDED_ML_MASKED_MSE_BACKWARD_F32,
			Self::MlGaeF32 => &BOUNDED_ML_GAE_F32,
			Self::MlRolloutAppendF32 => &BOUNDED_ML_APPEND_F32,
			Self::MlRolloutResetU8 => &BOUNDED_ML_RESET_U8,
			Self::MlReplayAppendBatchF32 => &BOUNDED_ML_APPEND_BATCH_F32,
			Self::MlReplaySampleF32 => &BOUNDED_ML_SAMPLE_F32,
			Self::MlDqnTargetF32 => &BOUNDED_ML_DQN_TARGET_F32,
			Self::MlSacTargetF32 => &BOUNDED_ML_SAC_TARGET_F32,
			Self::MlCartPoleResetF32 => &BOUNDED_ML_CART_POLE_RESET_F32,
			Self::MlCartPoleStepF32 => &BOUNDED_ML_CART_POLE_STEP_F32,
			Self::MlLunarLanderResetF32 => &BOUNDED_ML_LUNAR_LANDER_RESET_F32,
			Self::MlLunarLanderStepF32 => &BOUNDED_ML_LUNAR_LANDER_STEP_F32,
			Self::MlRmsNormGatedF32 => &BOUNDED_ML_RMS_NORM_GATED_F32,
			Self::MlRmsNormGatedBackwardF32 => &BOUNDED_ML_RMS_NORM_GATED_BACKWARD_F32,
			Self::MlMamba3PreprocessF32 => &BOUNDED_ML_MAMBA3_PREPROCESS_F32,
			Self::MlMamba3PreprocessBackwardF32 => &BOUNDED_ML_MAMBA3_PREPROCESS_BACKWARD_F32,
			Self::MlMamba3PreprocessBackwardReduceF32 => {
				&BOUNDED_ML_MAMBA3_PREPROCESS_BACKWARD_REDUCE_F32
			}
			Self::MlMamba3SisoF32 => &BOUNDED_ML_MAMBA3_SISO_F32,
			Self::MlMamba3SisoBackwardPrepareF32 => &BOUNDED_ML_MAMBA3_SISO_BACKWARD_F32,
			Self::MlMamba3SisoStepF32 => &BOUNDED_ML_MAMBA3_SISO_STEP_F32,
			Self::MlMamba3SisoBackwardStateF32 => &BOUNDED_ML_MAMBA3_SISO_BACKWARD_STATE_F32,
			Self::MlMamba3SisoBackwardReverseP16F32 => &BOUNDED_ML_MAMBA3_SISO_BACKWARD_REVERSE_P16_F32,
			Self::MlMamba3SisoBackwardFinalizeF32 => &BOUNDED_ML_MAMBA3_SISO_BACKWARD_FINALIZE_F32,
			Self::MlMamba3SisoBackwardReduceF32 => &BOUNDED_ML_MAMBA3_SISO_BACKWARD_REDUCE_F32,
			Self::MlMamba3SisoBackwardGroupReduceF32 => &BOUNDED_ML_MAMBA3_SISO_BACKWARD_GROUP_REDUCE_F32,
			Self::MlMamba3MimoF32 => &BOUNDED_ML_MAMBA3_MIMO_F32,
			Self::MlMamba3MimoBackwardCoreF32 => &BOUNDED_ML_MAMBA3_MIMO_BACKWARD_F32,
			Self::MlMamba3MimoStepF32 => &BOUNDED_ML_MAMBA3_MIMO_STEP_F32,
			Self::MlMamba3MimoBackwardPrepareF32 => &BOUNDED_ML_MAMBA3_MIMO_BACKWARD_PREPARE_F32,
			Self::MlMamba3MimoBackwardPostF32 => &BOUNDED_ML_MAMBA3_MIMO_BACKWARD_POST_F32,
			Self::MlMamba3MimoBackwardRotateF32 => &BOUNDED_ML_MAMBA3_MIMO_BACKWARD_ROTATE_F32,
			Self::MlMamba3MimoBackwardReduceF32 => &BOUNDED_ML_MAMBA3_MIMO_BACKWARD_REDUCE_F32,
			Self::MlMamba3SisoBackwardGenericF32 => &BOUNDED_ML_MAMBA3_SISO_BACKWARD_GENERIC_F32,
			Self::MlMamba3SisoBackwardGenericReduceF32 => {
				&BOUNDED_ML_MAMBA3_SISO_BACKWARD_GENERIC_REDUCE_F32
			}
			Self::MlMamba3SisoChunkSummaryF32 => &BOUNDED_ML_MAMBA3_SISO_CHUNK_SUMMARY_F32,
			Self::MlMamba3SisoChunkPrefixF32 => &BOUNDED_ML_MAMBA3_SISO_CHUNK_PREFIX_F32,
			Self::MlMamba3SisoChunkDpreF32 => &BOUNDED_ML_MAMBA3_SISO_CHUNK_DPRE_F32,
			Self::MlMamba3SisoChunkBackwardSummaryF32 => {
				&BOUNDED_ML_MAMBA3_SISO_CHUNK_BACKWARD_SUMMARY_F32
			}
			Self::MlMamba3SisoChunkBackwardPrefixF32 => &BOUNDED_ML_MAMBA3_SISO_CHUNK_BACKWARD_PREFIX_F32,
			Self::MlMamba3SisoChunkBackwardF32 => &BOUNDED_ML_MAMBA3_SISO_CHUNK_BACKWARD_F32,
			Self::MlMamba3SisoChunkFinalizeF32 => &BOUNDED_ML_MAMBA3_SISO_CHUNK_FINALIZE_F32,
			Self::MlMamba3SisoChunkReduceF32 => &BOUNDED_ML_MAMBA3_SISO_CHUNK_REDUCE_F32,
			Self::MlVqAssignF32 => &BOUNDED_ML_VQ_ASSIGN_F32,
			Self::MlVqLookupF32 => &BOUNDED_ML_VQ_LOOKUP_F32,
			Self::MlVqEmaUpdateF32 => &BOUNDED_ML_VQ_EMA_UPDATE_F32,
			Self::AudioGainF32 => &BOUNDED_AUDIO_GAIN_F32,
			Self::AudioClipF32 => &BOUNDED_AUDIO_CLIP_F32,
			Self::AudioSaturateF32 => &BOUNDED_AUDIO_SATURATE_F32,
			Self::AudioResampleF32 => &BOUNDED_AUDIO_RESAMPLE_F32,
			Self::AudioFadeF32 => &BOUNDED_AUDIO_FADE_F32,
			Self::AudioMixF32 => &BOUNDED_AUDIO_MIX_F32,
			Self::AudioAmplitudeToDbF32 => &BOUNDED_AUDIO_AMPLITUDE_TO_DB_F32,
			Self::AudioWaveformEnvelopeF32 => &BOUNDED_AUDIO_WAVEFORM_ENVELOPE_F32,
			Self::AudioPreEmphasisF32 => &BOUNDED_AUDIO_PRE_EMPHASIS_F32,
			Self::AudioToMonoF32 => &BOUNDED_AUDIO_TO_MONO_F32,
			Self::AudioNormalizeLevelF32 => &BOUNDED_AUDIO_NORMALIZE_LEVEL_F32,
			Self::AudioNormalizeApplyF32 => &BOUNDED_AUDIO_NORMALIZE_APPLY_F32,
			Self::AudioBiquadSummaryF32 => &BOUNDED_AUDIO_BIQUAD_SUMMARY_F32,
			Self::AudioBiquadScanF32 => &BOUNDED_AUDIO_BIQUAD_SCAN_F32,
			Self::AudioBiquadApplyF32 => &BOUNDED_AUDIO_BIQUAD_APPLY_F32,
			Self::AudioReverbCombF32 => &BOUNDED_AUDIO_REVERB_COMB_F32,
			Self::AudioReverbSumF32 => &BOUNDED_AUDIO_REVERB_SUM_F32,
			Self::AudioReverbAllpassF32 => &BOUNDED_AUDIO_REVERB_ALLPASS_F32,
			Self::AudioReverbMixF32 => &BOUNDED_AUDIO_REVERB_MIX_F32,
			Self::AudioStftF32 => &BOUNDED_AUDIO_STFT_F32,
			Self::AudioMelFilterbankF32 => &BOUNDED_AUDIO_MEL_FILTERBANK_F32,
			Self::AudioMelNormalizeF32 => &BOUNDED_AUDIO_MEL_NORMALIZE_F32,
			Self::AudioMfccDctF32 => &BOUNDED_AUDIO_MFCC_DCT_F32,
			Self::AudioSosFilterF32 => &BOUNDED_AUDIO_SOS_FILTER_F32,
			Self::CryptographyShake128U8 => &BOUNDED_CRYPTOGRAPHY_SHAKE128_U8,
			Self::CryptographyShake256U8 => &BOUNDED_CRYPTOGRAPHY_SHAKE256_U8,
			Self::CryptographyKeccakF1600U8 => &BOUNDED_CRYPTOGRAPHY_KECCAK_F1600_U8,
			Self::CryptographyMerkleReduceU8 => &BOUNDED_CRYPTOGRAPHY_MERKLE_REDUCE_U8,
			Self::CryptographyMerkleCopyU8 => &BOUNDED_CRYPTOGRAPHY_MERKLE_COPY_U8,
			Self::CryptographyMlDsa65VerifyU8 => &BOUNDED_CRYPTOGRAPHY_ML_DSA_65_VERIFY_U8,
			Self::CryptographyMlDsa44VerifyU8 => &BOUNDED_CRYPTOGRAPHY_ML_DSA_44_VERIFY_U8,
			Self::CryptographyMlDsa87VerifyU8 => &BOUNDED_CRYPTOGRAPHY_ML_DSA_87_VERIFY_U8,
			Self::CryptographyMlDsa65VerifyPrehashedU8 => {
				&BOUNDED_CRYPTOGRAPHY_ML_DSA_65_VERIFY_PREHASHED_U8
			}
			Self::CryptographyMlDsa44VerifyPrehashedU8 => {
				&BOUNDED_CRYPTOGRAPHY_ML_DSA_44_VERIFY_PREHASHED_U8
			}
			Self::CryptographyMlDsa87VerifyPrehashedU8 => {
				&BOUNDED_CRYPTOGRAPHY_ML_DSA_87_VERIFY_PREHASHED_U8
			}
			Self::CryptographyMlDsa65VerifyHashMessageU8 => {
				&BOUNDED_CRYPTOGRAPHY_ML_DSA_65_VERIFY_HASH_MESSAGE_U8
			}
			Self::CryptographyMlDsa44VerifyHashMessageU8 => {
				&BOUNDED_CRYPTOGRAPHY_ML_DSA_44_VERIFY_HASH_MESSAGE_U8
			}
			Self::CryptographyMlDsa87VerifyHashMessageU8 => {
				&BOUNDED_CRYPTOGRAPHY_ML_DSA_87_VERIFY_HASH_MESSAGE_U8
			}
			Self::CryptographyMlKemKeygenU8 => &BOUNDED_CRYPTOGRAPHY_ML_KEM_KEYGEN_U8,
			Self::CryptographyMlKemEncapsU8 => &BOUNDED_CRYPTOGRAPHY_ML_KEM_ENCAPS_U8,
			Self::CryptographyMlKemDecapsU8 => &BOUNDED_CRYPTOGRAPHY_ML_KEM_DECAPS_U8,
			Self::CryptographyMlDsaKeygenU8 => &BOUNDED_CRYPTOGRAPHY_ML_DSA_KEYGEN_U8,
			Self::CryptographyMlDsaSignU8 => &BOUNDED_CRYPTOGRAPHY_ML_DSA_SIGN_U8,
			Self::CryptographyMlDsaSignMessageU8 => &BOUNDED_CRYPTOGRAPHY_ML_DSA_SIGN_MESSAGE_U8,
			Self::CryptographyMlDsaSignPrehashedU8 => &BOUNDED_CRYPTOGRAPHY_ML_DSA_SIGN_PREHASHED_U8,
			Self::CryptographyMlDsaSignHashMessageU8 => &BOUNDED_CRYPTOGRAPHY_ML_DSA_SIGN_HASH_MESSAGE_U8,
			Self::ImageResizeNearestF32 => &BOUNDED_IMAGE_RESIZE_NEAREST_F32,
			Self::ImageResizeBilinearF32 => &BOUNDED_IMAGE_RESIZE_BILINEAR_F32,
			Self::ImageCropF32 => &BOUNDED_IMAGE_CROP_F32,
			Self::ImageFlipF32 => &BOUNDED_IMAGE_FLIP_F32,
			Self::ImageRotateF32 => &BOUNDED_IMAGE_ROTATE_F32,
			Self::ImagePadF32 => &BOUNDED_IMAGE_PAD_F32,
			Self::ImageCenterCropF32 => &BOUNDED_IMAGE_CENTER_CROP_F32,
			Self::ImageRemapF32 => &BOUNDED_IMAGE_REMAP_F32,
			Self::ImageWarpAffineF32 => &BOUNDED_IMAGE_WARP_AFFINE_F32,
			Self::ImageWarpPerspectiveF32 => &BOUNDED_IMAGE_WARP_PERSPECTIVE_F32,
			Self::ImageThresholdBinaryF32 => &BOUNDED_IMAGE_THRESHOLD_BINARY_F32,
			Self::ImageThresholdBinaryInvF32 => &BOUNDED_IMAGE_THRESHOLD_BINARY_INV_F32,
			Self::ImageThresholdTruncateF32 => &BOUNDED_IMAGE_THRESHOLD_TRUNCATE_F32,
			Self::ImageThresholdToZeroF32 => &BOUNDED_IMAGE_THRESHOLD_TO_ZERO_F32,
			Self::ImageThresholdToZeroInvF32 => &BOUNDED_IMAGE_THRESHOLD_TO_ZERO_INV_F32,
			Self::ImageInRangeF32 => &BOUNDED_IMAGE_IN_RANGE_F32,
			Self::ImageClampF32 => &BOUNDED_IMAGE_CLAMP_F32,
			Self::ImageInvertF32 => &BOUNDED_IMAGE_INVERT_F32,
			Self::ImageBrightnessContrastF32 => &BOUNDED_IMAGE_BRIGHTNESS_CONTRAST_F32,
			Self::ImageGammaContrastF32 => &BOUNDED_IMAGE_GAMMA_CONTRAST_F32,
			Self::ImageSolarizeF32 => &BOUNDED_IMAGE_SOLARIZE_F32,
			Self::ImagePosterizeF32 => &BOUNDED_IMAGE_POSTERIZE_F32,
			Self::ImageGrayscaleF32 => &BOUNDED_IMAGE_GRAYSCALE_F32,
			Self::ImageAlphaBlendF32 => &BOUNDED_IMAGE_ALPHA_BLEND_F32,
			Self::ImageCompositeF32 => &BOUNDED_IMAGE_COMPOSITE_F32,
			Self::ImageEraseF32 => &BOUNDED_IMAGE_ERASE_F32,
			Self::ImageColorTwistF32 => &BOUNDED_IMAGE_COLOR_TWIST_F32,
			Self::ImageChannelReorderF32 => &BOUNDED_IMAGE_CHANNEL_REORDER_F32,
			Self::ImageGaussianNoiseF32 => &BOUNDED_IMAGE_GAUSSIAN_NOISE_F32,
			Self::ImageSaltPepperNoiseF32 => &BOUNDED_IMAGE_SALT_PEPPER_NOISE_F32,
			Self::ImageConvolve2dF32 => &BOUNDED_IMAGE_CONVOLVE_2D_F32,
			Self::ImageSeparableConvolve2dF32 => &BOUNDED_IMAGE_SEPARABLE_CONVOLVE_2D_F32,
			Self::ImageAverageBlurF32 => &BOUNDED_IMAGE_AVERAGE_BLUR_F32,
			Self::ImageSobelF32 => &BOUNDED_IMAGE_SOBEL_F32,
			Self::ImageScharrF32 => &BOUNDED_IMAGE_SCHARR_F32,
			Self::ImageLaplacianF32 => &BOUNDED_IMAGE_LAPLACIAN_F32,
			Self::ImageErodeF32 => &BOUNDED_IMAGE_ERODE_F32,
			Self::ImageDilateF32 => &BOUNDED_IMAGE_DILATE_F32,
			Self::ImageMorphologyOpenF32 => &BOUNDED_IMAGE_MORPHOLOGY_OPEN_F32,
			Self::ImageMorphologyCloseF32 => &BOUNDED_IMAGE_MORPHOLOGY_CLOSE_F32,
			Self::ImageMorphologyGradientF32 => &BOUNDED_IMAGE_MORPHOLOGY_GRADIENT_F32,
			Self::ImageGaussianBlurF32 => &BOUNDED_IMAGE_GAUSSIAN_BLUR_F32,
			Self::ImageSharpenF32 => &BOUNDED_IMAGE_SHARPEN_F32,
			Self::ImageMedianBlurF32 => &BOUNDED_IMAGE_MEDIAN_BLUR_F32,
			Self::ImageBilateralFilterF32 => &BOUNDED_IMAGE_BILATERAL_FILTER_F32,
			Self::ImageUnsharpMaskF32 => &BOUNDED_IMAGE_UNSHARP_MASK_F32,
			Self::ImageMorphologyTopHatF32 => &BOUNDED_IMAGE_MORPHOLOGY_TOP_HAT_F32,
			Self::ImageMorphologyBlackHatF32 => &BOUNDED_IMAGE_MORPHOLOGY_BLACK_HAT_F32,
			Self::ImageAdaptiveThresholdMeanF32 => &BOUNDED_IMAGE_ADAPTIVE_THRESHOLD_MEAN_F32,
			Self::ImageAdaptiveThresholdGaussianF32 => &BOUNDED_IMAGE_ADAPTIVE_THRESHOLD_GAUSSIAN_F32,
			Self::ImageNormalizeF32 => &BOUNDED_IMAGE_NORMALIZE_F32,
			Self::ImageConvertColorF32 => &BOUNDED_IMAGE_CONVERT_COLOR_F32,
			Self::ImageResizeNormalizeF32 => &BOUNDED_IMAGE_RESIZE_NORMALIZE_F32,
			Self::ImageSegmentationOverlayF32 => &BOUNDED_IMAGE_SEGMENTATION_OVERLAY_F32,
			Self::VisionBoxIouF32 => &BOUNDED_VISION_BOX_IOU_F32,
			Self::VisionNmsF32 => &BOUNDED_VISION_NMS_F32,
			Self::VisionConfusionMatrixI32 => &BOUNDED_VISION_CONFUSION_MATRIX_I32,
			Self::VisionBinaryMaskCountsU8 => &BOUNDED_VISION_BINARY_MASK_COUNTS_U8,
			Self::VisionDetectionMetricCurvesF32 => &BOUNDED_VISION_DETECTION_METRIC_CURVES_F32,
			Self::VisionDetectionAveragePrecisionF32 => &BOUNDED_VISION_DETECTION_AVERAGE_PRECISION_F32,
			Self::VisionDetectionMeanAveragePrecisionF32 => {
				&BOUNDED_VISION_DETECTION_MEAN_AVERAGE_PRECISION_F32
			}
			Self::VisionSegmentationConfusionI32 => &BOUNDED_VISION_SEGMENTATION_CONFUSION_I32,
			Self::VisionSegmentationMetricsF32 => &BOUNDED_VISION_SEGMENTATION_METRICS_F32,
			Self::VisionConfusionMatrixClearU32 => &BOUNDED_VISION_CONFUSION_MATRIX_CLEAR_U32,
			Self::VisionBinaryMaskCountsClearU32 => &BOUNDED_VISION_BINARY_MASK_COUNTS_CLEAR_U32,
			Self::VisionSegmentationConfusionClearU32 => &BOUNDED_VISION_SEGMENTATION_CONFUSION_CLEAR_U32,
		}
	}

	pub(crate) const fn requires_secret_storage(self) -> bool {
		matches!(
			self,
			Self::CryptographyMlKemKeygenU8
				| Self::CryptographyMlKemEncapsU8
				| Self::CryptographyMlKemDecapsU8
				| Self::CryptographyMlDsaKeygenU8
				| Self::CryptographyMlDsaSignU8
				| Self::CryptographyMlDsaSignMessageU8
				| Self::CryptographyMlDsaSignPrehashedU8
				| Self::CryptographyMlDsaSignHashMessageU8
		)
	}

	pub(crate) const fn bounded_buffer_count(self) -> u32 {
		match self {
			Self::MatrixAddF32 => 3,
			Self::MatrixAddI32 => 3,
			Self::MatrixAddBroadcastF32 => 3,
			Self::MatrixAddBroadcastI32 => 3,
			Self::MatrixSubF32 => 3,
			Self::MatrixSubBroadcastF32 => 3,
			Self::MatrixMulF32 => 3,
			Self::MatrixMulBroadcastF32 => 3,
			Self::MatrixDivF32 => 3,
			Self::MatrixDivBroadcastF32 => 3,
			Self::MatrixScaleF32 => 2,
			Self::MatrixNegF32 => 2,
			Self::MatrixAbsF32 => 2,
			Self::MatrixLogF32 => 2,
			Self::MatrixSqrtF32 => 2,
			Self::MatrixPowF32 => 2,
			Self::MatrixAddScalarF32 => 2,
			Self::MatrixSubScalarF32 => 2,
			Self::MatrixDivScalarF32 => 2,
			Self::MatrixExpF32 => 2,
			Self::MatrixSinF32 => 2,
			Self::MatrixCosF32 => 2,
			Self::MatrixReciprocalF32 => 2,
			Self::MatrixClampMaxF32 => 2,
			Self::MatrixClampMinF32 => 2,
			Self::MatrixCopyF32 => 2,
			Self::MatrixCopyU8 => 2,
			Self::MatrixCopyI32 => 2,
			Self::MatrixCopyU32 => 2,
			Self::MatrixMatMulNtTiledF32 => 3,
			Self::MatrixSoftmaxF32 => 2,
			Self::MatrixSoftmaxBackwardF32 => 3,
			Self::MatrixLogSoftmaxF32 => 2,
			Self::MatrixLogSoftmaxBackwardF32 => 3,
			Self::MatrixSumF32 => 2,
			Self::MatrixSumAxisF32 => 2,
			Self::MatrixSumBackwardF32 => 2,
			Self::MatrixCategoricalAccuracyCountF32 => 3,
			Self::MatrixMaskedCategoricalAccuracyCountF32 => 4,
			Self::MatrixPhiloxUniformF32 => 2,
			Self::MatrixPhiloxNormalF32 => 2,
			Self::MatrixPhiloxUniformReplayF32 => 3,
			Self::MatrixPhiloxNormalReplayF32 => 3,
			Self::MatrixPhiloxReplayAdvanceU32 => 1,
			Self::MatrixDropoutF32 => 2,
			Self::MatrixDropoutBackwardF32 => 2,
			Self::MatrixSampleLogitsGreedyF32 => 2,
			Self::MatrixSampleLogitsDenseF32 => 3,
			Self::MatrixSampleLogitsSortedF32 => 4,
			Self::MatrixDropoutReplayF32 => 3,
			Self::MatrixDropoutBackwardReplayF32 => 3,
			Self::MatrixTopKF32 => 3,
			Self::MatrixTopKMaskF32 => 2,
			Self::MatrixMoeExpertPlanU32 => 7,
			Self::MatrixMoeRoutingBiasUpdateF32 => 2,
			Self::MatrixSliceF32 => 2,
			Self::MatrixSliceBackwardF32 => 2,
			Self::MatrixRepeatInterleaveF32 => 2,
			Self::MatrixRepeatInterleaveBackwardF32 => 2,
			Self::MatrixGatherF32 => 3,
			Self::MatrixGatherBackwardF32 => 3,
			Self::MatrixGatherLastDimF32 => 3,
			Self::MatrixGatherLastDimBackwardF32 => 3,
			Self::MatrixConcatF32 => 2,
			Self::MatrixTransposeF32 => 2,
			Self::MatrixEqualF32 => 2,
			Self::MlPpoClippedPolicyF32 => 4,
			Self::MlPpoClippedPolicyBackwardF32 => 4,
			Self::MlLinearF32 => 4,
			Self::MlLinearBackwardF32 => 3,
			Self::MlLinearParameterBackwardF32 => 4,
			Self::MlCrossEntropyF32 => 3,
			Self::MlCrossEntropySumF32 => 2,
			Self::MlCrossEntropyBackwardF32 => 3,
			Self::MlMaskedCrossEntropyF32 => 4,
			Self::MlMaskedCrossEntropyBackwardF32 => 4,
			Self::MlSmoothL1F32 => 3,
			Self::MlSmoothL1BackwardF32 => 3,
			Self::MlSmoothL1MeanF32 => 3,
			Self::MlMseF32 => 3,
			Self::MlMseBackwardF32 => 3,
			Self::MlL1F32 => 3,
			Self::MlL1BackwardF32 => 3,
			Self::MlBceF32 => 3,
			Self::MlBceBackwardF32 => 3,
			Self::MlSgdF32 => 2,
			Self::MlClipGradNormReduceF32 => 18,
			Self::MlClipGradNormScaleF32 => 18,
			Self::MlSgdMomentumF32 => 3,
			Self::MlAdamF32 => 4,
			Self::MlMuonNesterovF32 => 3,
			Self::MlMuonVectorF32 => 3,
			Self::MlMuonNormalizeF32 => 3,
			Self::MlMuonMatMulAxpbyF32 => 4,
			Self::MlMuonLinearCombinationF32 => 3,
			Self::MlMuonTransposeF32 => 2,
			Self::MlMuonApplyF32 => 2,
			Self::MlAdamWF32 => 4,
			Self::MlAdamWGraphAdvanceU32 => 1,
			Self::MlAdamWGraphF32 => 5,
			Self::MlEmbeddingF32 => 3,
			Self::MlEmbeddingBackwardF32 => 3,
			Self::MlChannelNormF32 => 4,
			Self::MlChannelNormBackwardF32 => 6,
			Self::MlChannelNormReluF32 => 4,
			Self::MlChannelNormReluBackwardF32 => 7,
			Self::MlEmbeddingU8F32 => 3,
			Self::MlEmbeddingBackwardU8F32 => 3,
			Self::MlRnnScanF32 => 5,
			Self::MlRnnScanBackwardF32 => 7,
			Self::MlLayerNormF32 => 6,
			Self::MlLayerNormBackwardF32 => 6,
			Self::MlRmsNormF32 => 3,
			Self::MlRmsNormBackwardF32 => 5,
			Self::MlGeluF32 => 2,
			Self::MlGeluBackwardF32 => 3,
			Self::MlSiluF32 => 2,
			Self::MlSiluBackwardF32 => 3,
			Self::MlReluF32 => 2,
			Self::MlReluBackwardF32 => 3,
			Self::MlTanhF32 => 2,
			Self::MlTanhBackwardF32 => 3,
			Self::MlSigmoidF32 => 2,
			Self::MlSigmoidBackwardF32 => 3,
			Self::MlLeakyReluF32 => 2,
			Self::MlLeakyReluBackwardF32 => 3,
			Self::MlEluF32 => 2,
			Self::MlEluBackwardF32 => 3,
			Self::MlMishF32 => 2,
			Self::MlMishBackwardF32 => 3,
			Self::MlSoftplusF32 => 2,
			Self::MlSoftplusBackwardF32 => 3,
			Self::MlQkvProjectionBiasF32 => 10,
			Self::MlSwigluF32 => 3,
			Self::MlSwigluBackwardF32 => 5,
			Self::MlGateUpSwigluBiasF32 => 6,
			Self::MlAdamWMany4F32 => 16,
			Self::MlAdamWMany4GraphF32 => 17,
			Self::MlRopeF32 => 2,
			Self::MlRopeBackwardF32 => 2,
			Self::MlAvgPool2dF32 => 2,
			Self::MlAvgPool2dBackwardF32 => 2,
			Self::MlMaxPool2dF32 => 3,
			Self::MlMaxPool2dBackwardF32 => 3,
			Self::MlAdaptiveAvgPool2dF32 => 2,
			Self::MlAdaptiveAvgPool2dBackwardF32 => 2,
			Self::MlBatchNorm2dF32 => 3,
			Self::MlBatchNorm2dWithStatsF32 => 6,
			Self::MlBatchNorm2dRunningUpdateF32 => 6,
			Self::MlBatchNorm2dBackwardF32 => 6,
			Self::MlBatchNorm2dInputBackwardF32 => 8,
			Self::MlUpsample2dNearestF32 => 2,
			Self::MlUpsample2dBilinearF32 => 2,
			Self::MlUpsample2dNearestBackwardF32 => 2,
			Self::MlUpsample2dBilinearBackwardF32 => 2,
			Self::MlConv2dF32 => 4,
			Self::MlConv2dBackwardF32 => 3,
			Self::MlConv2dParameterBackwardF32 => 4,
			Self::MlConv1dIm2ColF32 => 2,
			Self::MlConv1dBiasAddF32 => 2,
			Self::MlConv1dTransposeF32 => 2,
			Self::MlConv1dBackwardF32 => 3,
			Self::MlConv1dParameterBackwardF32 => 4,
			Self::MlConvTranspose1dF32 => 3,
			Self::MlConvTranspose1dBackwardF32 => 2,
			Self::MlConvTranspose2dF32 => 3,
			Self::MlConvTranspose2dBiasAddF32 => 2,
			Self::MlConvTranspose2dBackwardF32 => 3,
			Self::MlConvTranspose2dParameterBackwardF32 => 4,
			Self::MlGruScanF32 => 5,
			Self::MlGruScanBackwardF32 => 7,
			Self::MlGruCellF32 => 6,
			Self::MlGruCellBackwardF32 => 7,
			Self::MlRnnCellF32 => 6,
			Self::MlRnnCellBackwardF32 => 5,
			Self::MlBmmF32 => 3,
			Self::MlBmmTiled16F32 => 3,
			Self::MlBmmNtF32 => 3,
			Self::MlBmmNtTiled16F32 => 3,
			Self::MlBmmTnF32 => 3,
			Self::MlBmmTnTiled16F32 => 3,
			Self::MlSplitHeadsF32 => 2,
			Self::MlMergeHeadsF32 => 2,
			Self::MlSoftmaxScaledMaskedF32 => 3,
			Self::MlSoftmaxScaledMaskedN32F32 => 3,
			Self::MlSoftmaxScaledMaskedBackwardF32 => 3,
			Self::MlSdpaSoftmaxF32 => 3,
			Self::MlSdpaSoftmaxN32F32 => 3,
			Self::MlFlashAttentionCausalF32 => 5,
			Self::MlFlashAttentionCausalBackwardQF32 => 7,
			Self::MlFlashAttentionCausalBackwardKvF32 => 8,
			Self::MlMoeRouteWeightsF32 => 3,
			Self::MlMoeRouteWeightsBackwardF32 => 5,
			Self::MlMoeGatherF32 => 3,
			Self::MlMoeGatherBackwardF32 => 3,
			Self::MlMoeCombineF32 => 4,
			Self::MlMoeCombineBackwardF32 => 7,
			Self::MlGroupedLinearMF32 => 5,
			Self::MlGroupedLinearMDataBackwardF32 => 4,
			Self::MlGroupedLinearMParameterBackwardF32 => 5,
			Self::MlSiluMulF32 => 2,
			Self::MlSiluMulBackwardF32 => 3,
			Self::MlGroupedGemmMF32 => 4,
			Self::MlGroupedGemmMDataBackwardF32 => 4,
			Self::MlGroupedGemmMParameterBackwardF32 => 4,
			Self::MlFlowLinearMatchF32 => 5,
			Self::MlFlowEulerStepF32 => 3,
			Self::MlFlowMaskedMseF32 => 5,
			Self::MlFlowMaskedMseBackwardF32 => 6,
			Self::MlGaeF32 => 7,
			Self::MlRolloutAppendF32 => 17,
			Self::MlRolloutResetU8 => 1,
			Self::MlReplayAppendBatchF32 => 12,
			Self::MlReplaySampleF32 => 13,
			Self::MlDqnTargetF32 => 5,
			Self::MlSacTargetF32 => 7,
			Self::MlCartPoleResetF32 => 4,
			Self::MlCartPoleStepF32 => 8,
			Self::MlLunarLanderResetF32 => 7,
			Self::MlLunarLanderStepF32 => 13,
			Self::MlRmsNormGatedF32 => 5,
			Self::MlRmsNormGatedBackwardF32 => 9,
			Self::MlMamba3PreprocessF32 => 10,
			Self::MlMamba3PreprocessBackwardF32 => 12,
			Self::MlMamba3PreprocessBackwardReduceF32 => 2,
			Self::MlMamba3SisoF32 => 12,
			Self::MlMamba3SisoBackwardPrepareF32 => 15,
			Self::MlMamba3SisoStepF32 => 16,
			Self::MlMamba3SisoBackwardStateF32 => 13,
			Self::MlMamba3SisoBackwardReverseP16F32 => 21,
			Self::MlMamba3SisoBackwardFinalizeF32 => 9,
			Self::MlMamba3SisoBackwardReduceF32 => 8,
			Self::MlMamba3SisoBackwardGroupReduceF32 => 4,
			Self::MlMamba3MimoF32 => 16,
			Self::MlMamba3MimoBackwardCoreF32 => 21,
			Self::MlMamba3MimoStepF32 => 20,
			Self::MlMamba3MimoBackwardPrepareF32 => 17,
			Self::MlMamba3MimoBackwardPostF32 => 18,
			Self::MlMamba3MimoBackwardRotateF32 => 15,
			Self::MlMamba3MimoBackwardReduceF32 => 20,
			Self::MlMamba3SisoBackwardGenericF32 => 24,
			Self::MlMamba3SisoBackwardGenericReduceF32 => 13,
			Self::MlMamba3SisoChunkSummaryF32 => 6,
			Self::MlMamba3SisoChunkPrefixF32 => 3,
			Self::MlMamba3SisoChunkDpreF32 => 14,
			Self::MlMamba3SisoChunkBackwardSummaryF32 => 4,
			Self::MlMamba3SisoChunkBackwardPrefixF32 => 3,
			Self::MlMamba3SisoChunkBackwardF32 => 20,
			Self::MlMamba3SisoChunkFinalizeF32 => 9,
			Self::MlMamba3SisoChunkReduceF32 => 10,
			Self::MlVqAssignF32 => 4,
			Self::MlVqLookupF32 => 3,
			Self::MlVqEmaUpdateF32 => 8,
			Self::AudioGainF32 => 2,
			Self::AudioClipF32 => 2,
			Self::AudioSaturateF32 => 2,
			Self::AudioResampleF32 => 2,
			Self::AudioFadeF32 => 2,
			Self::AudioMixF32 => 3,
			Self::AudioAmplitudeToDbF32 => 2,
			Self::AudioWaveformEnvelopeF32 => 2,
			Self::AudioPreEmphasisF32 => 2,
			Self::AudioToMonoF32 => 2,
			Self::AudioNormalizeLevelF32 => 2,
			Self::AudioNormalizeApplyF32 => 3,
			Self::AudioBiquadSummaryF32 => 2,
			Self::AudioBiquadScanF32 => 2,
			Self::AudioBiquadApplyF32 => 3,
			Self::AudioReverbCombF32 => 2,
			Self::AudioReverbSumF32 => 5,
			Self::AudioReverbAllpassF32 => 2,
			Self::AudioReverbMixF32 => 3,
			Self::AudioStftF32 => 2,
			Self::AudioMelFilterbankF32 => 3,
			Self::AudioMelNormalizeF32 => 2,
			Self::AudioMfccDctF32 => 2,
			Self::AudioSosFilterF32 => 3,
			Self::CryptographyShake128U8 => 2,
			Self::CryptographyShake256U8 => 2,
			Self::CryptographyKeccakF1600U8 => 2,
			Self::CryptographyMerkleReduceU8 => 2,
			Self::CryptographyMerkleCopyU8 => 2,
			Self::CryptographyMlDsa65VerifyU8 => 6,
			Self::CryptographyMlDsa44VerifyU8 => 6,
			Self::CryptographyMlDsa87VerifyU8 => 6,
			Self::CryptographyMlDsa65VerifyPrehashedU8 => 6,
			Self::CryptographyMlDsa44VerifyPrehashedU8 => 6,
			Self::CryptographyMlDsa87VerifyPrehashedU8 => 6,
			Self::CryptographyMlDsa65VerifyHashMessageU8 => 6,
			Self::CryptographyMlDsa44VerifyHashMessageU8 => 6,
			Self::CryptographyMlDsa87VerifyHashMessageU8 => 6,
			Self::CryptographyMlKemKeygenU8 => 3,
			Self::CryptographyMlKemEncapsU8 => 5,
			Self::CryptographyMlKemDecapsU8 => 3,
			Self::CryptographyMlDsaKeygenU8 => 3,
			Self::CryptographyMlDsaSignU8 => 6,
			Self::CryptographyMlDsaSignMessageU8 => 7,
			Self::CryptographyMlDsaSignPrehashedU8 => 7,
			Self::CryptographyMlDsaSignHashMessageU8 => 7,
			Self::ImageResizeNearestF32 => 2,
			Self::ImageResizeBilinearF32 => 2,
			Self::ImageCropF32 => 2,
			Self::ImageFlipF32 => 2,
			Self::ImageRotateF32 => 2,
			Self::ImagePadF32 => 2,
			Self::ImageCenterCropF32 => 2,
			Self::ImageRemapF32 => 3,
			Self::ImageWarpAffineF32 => 3,
			Self::ImageWarpPerspectiveF32 => 3,
			Self::ImageThresholdBinaryF32 => 2,
			Self::ImageThresholdBinaryInvF32 => 2,
			Self::ImageThresholdTruncateF32 => 2,
			Self::ImageThresholdToZeroF32 => 2,
			Self::ImageThresholdToZeroInvF32 => 2,
			Self::ImageInRangeF32 => 2,
			Self::ImageClampF32 => 2,
			Self::ImageInvertF32 => 2,
			Self::ImageBrightnessContrastF32 => 2,
			Self::ImageGammaContrastF32 => 2,
			Self::ImageSolarizeF32 => 2,
			Self::ImagePosterizeF32 => 2,
			Self::ImageGrayscaleF32 => 2,
			Self::ImageAlphaBlendF32 => 4,
			Self::ImageCompositeF32 => 4,
			Self::ImageEraseF32 => 4,
			Self::ImageColorTwistF32 => 3,
			Self::ImageChannelReorderF32 => 2,
			Self::ImageGaussianNoiseF32 => 2,
			Self::ImageSaltPepperNoiseF32 => 2,
			Self::ImageConvolve2dF32 => 4,
			Self::ImageSeparableConvolve2dF32 => 4,
			Self::ImageAverageBlurF32 => 4,
			Self::ImageSobelF32 => 4,
			Self::ImageScharrF32 => 4,
			Self::ImageLaplacianF32 => 4,
			Self::ImageErodeF32 => 4,
			Self::ImageDilateF32 => 4,
			Self::ImageMorphologyOpenF32 => 4,
			Self::ImageMorphologyCloseF32 => 4,
			Self::ImageMorphologyGradientF32 => 4,
			Self::ImageGaussianBlurF32 => 4,
			Self::ImageSharpenF32 => 4,
			Self::ImageMedianBlurF32 => 4,
			Self::ImageBilateralFilterF32 => 4,
			Self::ImageUnsharpMaskF32 => 4,
			Self::ImageMorphologyTopHatF32 => 4,
			Self::ImageMorphologyBlackHatF32 => 4,
			Self::ImageAdaptiveThresholdMeanF32 => 4,
			Self::ImageAdaptiveThresholdGaussianF32 => 4,
			Self::ImageNormalizeF32 => 2,
			Self::ImageConvertColorF32 => 2,
			Self::ImageResizeNormalizeF32 => 2,
			Self::ImageSegmentationOverlayF32 => 4,
			Self::VisionBoxIouF32 => 3,
			Self::VisionNmsF32 => 5,
			Self::VisionConfusionMatrixI32 => 3,
			Self::VisionBinaryMaskCountsU8 => 3,
			Self::VisionDetectionMetricCurvesF32 => 12,
			Self::VisionDetectionAveragePrecisionF32 => 3,
			Self::VisionDetectionMeanAveragePrecisionF32 => 4,
			Self::VisionSegmentationConfusionI32 => 3,
			Self::VisionSegmentationMetricsF32 => 4,
			Self::VisionConfusionMatrixClearU32 => 1,
			Self::VisionBinaryMaskCountsClearU32 => 1,
			Self::VisionSegmentationConfusionClearU32 => 1,
		}
	}

	pub(crate) const fn index(self) -> usize {
		match self {
			Self::MatrixAddF32 => 0,
			Self::MatrixAddI32 => 1,
			Self::MatrixAddBroadcastF32 => 2,
			Self::MatrixAddBroadcastI32 => 3,
			Self::MatrixSubF32 => 4,
			Self::MatrixSubBroadcastF32 => 5,
			Self::MatrixMulF32 => 6,
			Self::MatrixMulBroadcastF32 => 7,
			Self::MatrixDivF32 => 8,
			Self::MatrixDivBroadcastF32 => 9,
			Self::MatrixScaleF32 => 10,
			Self::MatrixNegF32 => 11,
			Self::MatrixAbsF32 => 12,
			Self::MatrixLogF32 => 13,
			Self::MatrixSqrtF32 => 14,
			Self::MatrixPowF32 => 15,
			Self::MatrixAddScalarF32 => 16,
			Self::MatrixSubScalarF32 => 17,
			Self::MatrixDivScalarF32 => 18,
			Self::MatrixExpF32 => 19,
			Self::MatrixSinF32 => 20,
			Self::MatrixCosF32 => 21,
			Self::MatrixReciprocalF32 => 22,
			Self::MatrixClampMaxF32 => 23,
			Self::MatrixClampMinF32 => 24,
			Self::MatrixCopyF32 => 25,
			Self::MatrixCopyU8 => 26,
			Self::MatrixCopyI32 => 27,
			Self::MatrixCopyU32 => 28,
			Self::MatrixMatMulNtTiledF32 => 29,
			Self::MatrixSoftmaxF32 => 30,
			Self::MatrixSoftmaxBackwardF32 => 31,
			Self::MatrixLogSoftmaxF32 => 32,
			Self::MatrixLogSoftmaxBackwardF32 => 33,
			Self::MatrixSumF32 => 34,
			Self::MatrixSumAxisF32 => 35,
			Self::MatrixSumBackwardF32 => 36,
			Self::MatrixCategoricalAccuracyCountF32 => 37,
			Self::MatrixMaskedCategoricalAccuracyCountF32 => 38,
			Self::MatrixPhiloxUniformF32 => 39,
			Self::MatrixPhiloxNormalF32 => 40,
			Self::MatrixPhiloxUniformReplayF32 => 41,
			Self::MatrixPhiloxNormalReplayF32 => 42,
			Self::MatrixPhiloxReplayAdvanceU32 => 43,
			Self::MatrixDropoutF32 => 44,
			Self::MatrixDropoutBackwardF32 => 45,
			Self::MatrixSampleLogitsGreedyF32 => 46,
			Self::MatrixSampleLogitsDenseF32 => 47,
			Self::MatrixSampleLogitsSortedF32 => 48,
			Self::MatrixDropoutReplayF32 => 49,
			Self::MatrixDropoutBackwardReplayF32 => 50,
			Self::MatrixTopKF32 => 51,
			Self::MatrixTopKMaskF32 => 52,
			Self::MatrixMoeExpertPlanU32 => 53,
			Self::MatrixMoeRoutingBiasUpdateF32 => 54,
			Self::MatrixSliceF32 => 55,
			Self::MatrixSliceBackwardF32 => 56,
			Self::MatrixRepeatInterleaveF32 => 57,
			Self::MatrixRepeatInterleaveBackwardF32 => 58,
			Self::MatrixGatherF32 => 59,
			Self::MatrixGatherBackwardF32 => 60,
			Self::MatrixGatherLastDimF32 => 61,
			Self::MatrixGatherLastDimBackwardF32 => 62,
			Self::MatrixConcatF32 => 63,
			Self::MatrixTransposeF32 => 64,
			Self::MatrixEqualF32 => 65,
			Self::MlPpoClippedPolicyF32 => 66,
			Self::MlPpoClippedPolicyBackwardF32 => 67,
			Self::MlLinearF32 => 68,
			Self::MlLinearBackwardF32 => 69,
			Self::MlLinearParameterBackwardF32 => 70,
			Self::MlCrossEntropyF32 => 71,
			Self::MlCrossEntropySumF32 => 72,
			Self::MlCrossEntropyBackwardF32 => 73,
			Self::MlMaskedCrossEntropyF32 => 74,
			Self::MlMaskedCrossEntropyBackwardF32 => 75,
			Self::MlSmoothL1F32 => 76,
			Self::MlSmoothL1BackwardF32 => 77,
			Self::MlSmoothL1MeanF32 => 78,
			Self::MlMseF32 => 79,
			Self::MlMseBackwardF32 => 80,
			Self::MlL1F32 => 81,
			Self::MlL1BackwardF32 => 82,
			Self::MlBceF32 => 83,
			Self::MlBceBackwardF32 => 84,
			Self::MlSgdF32 => 85,
			Self::MlClipGradNormReduceF32 => 86,
			Self::MlClipGradNormScaleF32 => 87,
			Self::MlSgdMomentumF32 => 88,
			Self::MlAdamF32 => 89,
			Self::MlMuonNesterovF32 => 90,
			Self::MlMuonVectorF32 => 91,
			Self::MlMuonNormalizeF32 => 92,
			Self::MlMuonMatMulAxpbyF32 => 93,
			Self::MlMuonLinearCombinationF32 => 94,
			Self::MlMuonTransposeF32 => 95,
			Self::MlMuonApplyF32 => 96,
			Self::MlAdamWF32 => 97,
			Self::MlAdamWGraphAdvanceU32 => 98,
			Self::MlAdamWGraphF32 => 99,
			Self::MlEmbeddingF32 => 100,
			Self::MlEmbeddingBackwardF32 => 101,
			Self::MlChannelNormF32 => 102,
			Self::MlChannelNormBackwardF32 => 103,
			Self::MlChannelNormReluF32 => 104,
			Self::MlChannelNormReluBackwardF32 => 105,
			Self::MlEmbeddingU8F32 => 106,
			Self::MlEmbeddingBackwardU8F32 => 107,
			Self::MlRnnScanF32 => 108,
			Self::MlRnnScanBackwardF32 => 109,
			Self::MlLayerNormF32 => 110,
			Self::MlLayerNormBackwardF32 => 111,
			Self::MlRmsNormF32 => 112,
			Self::MlRmsNormBackwardF32 => 113,
			Self::MlGeluF32 => 114,
			Self::MlGeluBackwardF32 => 115,
			Self::MlSiluF32 => 116,
			Self::MlSiluBackwardF32 => 117,
			Self::MlReluF32 => 118,
			Self::MlReluBackwardF32 => 119,
			Self::MlTanhF32 => 120,
			Self::MlTanhBackwardF32 => 121,
			Self::MlSigmoidF32 => 122,
			Self::MlSigmoidBackwardF32 => 123,
			Self::MlLeakyReluF32 => 124,
			Self::MlLeakyReluBackwardF32 => 125,
			Self::MlEluF32 => 126,
			Self::MlEluBackwardF32 => 127,
			Self::MlMishF32 => 128,
			Self::MlMishBackwardF32 => 129,
			Self::MlSoftplusF32 => 130,
			Self::MlSoftplusBackwardF32 => 131,
			Self::MlQkvProjectionBiasF32 => 132,
			Self::MlSwigluF32 => 133,
			Self::MlSwigluBackwardF32 => 134,
			Self::MlGateUpSwigluBiasF32 => 135,
			Self::MlAdamWMany4F32 => 136,
			Self::MlAdamWMany4GraphF32 => 137,
			Self::MlRopeF32 => 138,
			Self::MlRopeBackwardF32 => 139,
			Self::MlAvgPool2dF32 => 140,
			Self::MlAvgPool2dBackwardF32 => 141,
			Self::MlMaxPool2dF32 => 142,
			Self::MlMaxPool2dBackwardF32 => 143,
			Self::MlAdaptiveAvgPool2dF32 => 144,
			Self::MlAdaptiveAvgPool2dBackwardF32 => 145,
			Self::MlBatchNorm2dF32 => 146,
			Self::MlBatchNorm2dWithStatsF32 => 147,
			Self::MlBatchNorm2dRunningUpdateF32 => 148,
			Self::MlBatchNorm2dBackwardF32 => 149,
			Self::MlBatchNorm2dInputBackwardF32 => 150,
			Self::MlUpsample2dNearestF32 => 151,
			Self::MlUpsample2dBilinearF32 => 152,
			Self::MlUpsample2dNearestBackwardF32 => 153,
			Self::MlUpsample2dBilinearBackwardF32 => 154,
			Self::MlConv2dF32 => 155,
			Self::MlConv2dBackwardF32 => 156,
			Self::MlConv2dParameterBackwardF32 => 157,
			Self::MlConv1dIm2ColF32 => 158,
			Self::MlConv1dBiasAddF32 => 159,
			Self::MlConv1dTransposeF32 => 160,
			Self::MlConv1dBackwardF32 => 161,
			Self::MlConv1dParameterBackwardF32 => 162,
			Self::MlConvTranspose1dF32 => 163,
			Self::MlConvTranspose1dBackwardF32 => 164,
			Self::MlConvTranspose2dF32 => 165,
			Self::MlConvTranspose2dBiasAddF32 => 166,
			Self::MlConvTranspose2dBackwardF32 => 167,
			Self::MlConvTranspose2dParameterBackwardF32 => 168,
			Self::MlGruScanF32 => 169,
			Self::MlGruScanBackwardF32 => 170,
			Self::MlGruCellF32 => 171,
			Self::MlGruCellBackwardF32 => 172,
			Self::MlRnnCellF32 => 173,
			Self::MlRnnCellBackwardF32 => 174,
			Self::MlBmmF32 => 175,
			Self::MlBmmTiled16F32 => 176,
			Self::MlBmmNtF32 => 177,
			Self::MlBmmNtTiled16F32 => 178,
			Self::MlBmmTnF32 => 179,
			Self::MlBmmTnTiled16F32 => 180,
			Self::MlSplitHeadsF32 => 181,
			Self::MlMergeHeadsF32 => 182,
			Self::MlSoftmaxScaledMaskedF32 => 183,
			Self::MlSoftmaxScaledMaskedN32F32 => 184,
			Self::MlSoftmaxScaledMaskedBackwardF32 => 185,
			Self::MlSdpaSoftmaxF32 => 186,
			Self::MlSdpaSoftmaxN32F32 => 187,
			Self::MlFlashAttentionCausalF32 => 188,
			Self::MlFlashAttentionCausalBackwardQF32 => 189,
			Self::MlFlashAttentionCausalBackwardKvF32 => 190,
			Self::MlMoeRouteWeightsF32 => 191,
			Self::MlMoeRouteWeightsBackwardF32 => 192,
			Self::MlMoeGatherF32 => 193,
			Self::MlMoeGatherBackwardF32 => 194,
			Self::MlMoeCombineF32 => 195,
			Self::MlMoeCombineBackwardF32 => 196,
			Self::MlGroupedLinearMF32 => 197,
			Self::MlGroupedLinearMDataBackwardF32 => 198,
			Self::MlGroupedLinearMParameterBackwardF32 => 199,
			Self::MlSiluMulF32 => 200,
			Self::MlSiluMulBackwardF32 => 201,
			Self::MlGroupedGemmMF32 => 202,
			Self::MlGroupedGemmMDataBackwardF32 => 203,
			Self::MlGroupedGemmMParameterBackwardF32 => 204,
			Self::MlFlowLinearMatchF32 => 205,
			Self::MlFlowEulerStepF32 => 206,
			Self::MlFlowMaskedMseF32 => 207,
			Self::MlFlowMaskedMseBackwardF32 => 208,
			Self::MlGaeF32 => 209,
			Self::MlRolloutAppendF32 => 210,
			Self::MlRolloutResetU8 => 211,
			Self::MlReplayAppendBatchF32 => 212,
			Self::MlReplaySampleF32 => 213,
			Self::MlDqnTargetF32 => 214,
			Self::MlSacTargetF32 => 215,
			Self::MlCartPoleResetF32 => 216,
			Self::MlCartPoleStepF32 => 217,
			Self::MlLunarLanderResetF32 => 218,
			Self::MlLunarLanderStepF32 => 219,
			Self::MlRmsNormGatedF32 => 220,
			Self::MlRmsNormGatedBackwardF32 => 221,
			Self::MlMamba3PreprocessF32 => 222,
			Self::MlMamba3PreprocessBackwardF32 => 223,
			Self::MlMamba3PreprocessBackwardReduceF32 => 224,
			Self::MlMamba3SisoF32 => 225,
			Self::MlMamba3SisoBackwardPrepareF32 => 226,
			Self::MlMamba3SisoStepF32 => 227,
			Self::MlMamba3SisoBackwardStateF32 => 228,
			Self::MlMamba3SisoBackwardReverseP16F32 => 229,
			Self::MlMamba3SisoBackwardFinalizeF32 => 230,
			Self::MlMamba3SisoBackwardReduceF32 => 231,
			Self::MlMamba3SisoBackwardGroupReduceF32 => 232,
			Self::MlMamba3MimoF32 => 233,
			Self::MlMamba3MimoBackwardCoreF32 => 234,
			Self::MlMamba3MimoStepF32 => 235,
			Self::MlMamba3MimoBackwardPrepareF32 => 236,
			Self::MlMamba3MimoBackwardPostF32 => 237,
			Self::MlMamba3MimoBackwardRotateF32 => 238,
			Self::MlMamba3MimoBackwardReduceF32 => 239,
			Self::MlMamba3SisoBackwardGenericF32 => 240,
			Self::MlMamba3SisoBackwardGenericReduceF32 => 241,
			Self::MlMamba3SisoChunkSummaryF32 => 242,
			Self::MlMamba3SisoChunkPrefixF32 => 243,
			Self::MlMamba3SisoChunkDpreF32 => 244,
			Self::MlMamba3SisoChunkBackwardSummaryF32 => 245,
			Self::MlMamba3SisoChunkBackwardPrefixF32 => 246,
			Self::MlMamba3SisoChunkBackwardF32 => 247,
			Self::MlMamba3SisoChunkFinalizeF32 => 248,
			Self::MlMamba3SisoChunkReduceF32 => 249,
			Self::MlVqAssignF32 => 250,
			Self::MlVqLookupF32 => 251,
			Self::MlVqEmaUpdateF32 => 252,
			Self::AudioGainF32 => 253,
			Self::AudioClipF32 => 254,
			Self::AudioSaturateF32 => 255,
			Self::AudioResampleF32 => 256,
			Self::AudioFadeF32 => 257,
			Self::AudioMixF32 => 258,
			Self::AudioAmplitudeToDbF32 => 259,
			Self::AudioWaveformEnvelopeF32 => 260,
			Self::AudioPreEmphasisF32 => 261,
			Self::AudioToMonoF32 => 262,
			Self::AudioNormalizeLevelF32 => 263,
			Self::AudioNormalizeApplyF32 => 264,
			Self::AudioBiquadSummaryF32 => 265,
			Self::AudioBiquadScanF32 => 266,
			Self::AudioBiquadApplyF32 => 267,
			Self::AudioReverbCombF32 => 268,
			Self::AudioReverbSumF32 => 269,
			Self::AudioReverbAllpassF32 => 270,
			Self::AudioReverbMixF32 => 271,
			Self::AudioStftF32 => 272,
			Self::AudioMelFilterbankF32 => 273,
			Self::AudioMelNormalizeF32 => 274,
			Self::AudioMfccDctF32 => 275,
			Self::AudioSosFilterF32 => 276,
			Self::CryptographyShake128U8 => 277,
			Self::CryptographyShake256U8 => 278,
			Self::CryptographyKeccakF1600U8 => 279,
			Self::CryptographyMerkleReduceU8 => 280,
			Self::CryptographyMerkleCopyU8 => 281,
			Self::CryptographyMlDsa65VerifyU8 => 282,
			Self::CryptographyMlDsa44VerifyU8 => 283,
			Self::CryptographyMlDsa87VerifyU8 => 284,
			Self::CryptographyMlDsa65VerifyPrehashedU8 => 285,
			Self::CryptographyMlDsa44VerifyPrehashedU8 => 286,
			Self::CryptographyMlDsa87VerifyPrehashedU8 => 287,
			Self::CryptographyMlDsa65VerifyHashMessageU8 => 288,
			Self::CryptographyMlDsa44VerifyHashMessageU8 => 289,
			Self::CryptographyMlDsa87VerifyHashMessageU8 => 290,
			Self::CryptographyMlKemKeygenU8 => 291,
			Self::CryptographyMlKemEncapsU8 => 292,
			Self::CryptographyMlKemDecapsU8 => 293,
			Self::CryptographyMlDsaKeygenU8 => 294,
			Self::CryptographyMlDsaSignU8 => 295,
			Self::CryptographyMlDsaSignMessageU8 => 296,
			Self::CryptographyMlDsaSignPrehashedU8 => 297,
			Self::CryptographyMlDsaSignHashMessageU8 => 298,
			Self::ImageResizeNearestF32 => 299,
			Self::ImageResizeBilinearF32 => 300,
			Self::ImageCropF32 => 301,
			Self::ImageFlipF32 => 302,
			Self::ImageRotateF32 => 303,
			Self::ImagePadF32 => 304,
			Self::ImageCenterCropF32 => 305,
			Self::ImageRemapF32 => 306,
			Self::ImageWarpAffineF32 => 307,
			Self::ImageWarpPerspectiveF32 => 308,
			Self::ImageThresholdBinaryF32 => 309,
			Self::ImageThresholdBinaryInvF32 => 310,
			Self::ImageThresholdTruncateF32 => 311,
			Self::ImageThresholdToZeroF32 => 312,
			Self::ImageThresholdToZeroInvF32 => 313,
			Self::ImageInRangeF32 => 314,
			Self::ImageClampF32 => 315,
			Self::ImageInvertF32 => 316,
			Self::ImageBrightnessContrastF32 => 317,
			Self::ImageGammaContrastF32 => 318,
			Self::ImageSolarizeF32 => 319,
			Self::ImagePosterizeF32 => 320,
			Self::ImageGrayscaleF32 => 321,
			Self::ImageAlphaBlendF32 => 322,
			Self::ImageCompositeF32 => 323,
			Self::ImageEraseF32 => 324,
			Self::ImageColorTwistF32 => 325,
			Self::ImageChannelReorderF32 => 326,
			Self::ImageGaussianNoiseF32 => 327,
			Self::ImageSaltPepperNoiseF32 => 328,
			Self::ImageConvolve2dF32 => 329,
			Self::ImageSeparableConvolve2dF32 => 330,
			Self::ImageAverageBlurF32 => 331,
			Self::ImageSobelF32 => 332,
			Self::ImageScharrF32 => 333,
			Self::ImageLaplacianF32 => 334,
			Self::ImageErodeF32 => 335,
			Self::ImageDilateF32 => 336,
			Self::ImageMorphologyOpenF32 => 337,
			Self::ImageMorphologyCloseF32 => 338,
			Self::ImageMorphologyGradientF32 => 339,
			Self::ImageGaussianBlurF32 => 340,
			Self::ImageSharpenF32 => 341,
			Self::ImageMedianBlurF32 => 342,
			Self::ImageBilateralFilterF32 => 343,
			Self::ImageUnsharpMaskF32 => 344,
			Self::ImageMorphologyTopHatF32 => 345,
			Self::ImageMorphologyBlackHatF32 => 346,
			Self::ImageAdaptiveThresholdMeanF32 => 347,
			Self::ImageAdaptiveThresholdGaussianF32 => 348,
			Self::ImageNormalizeF32 => 349,
			Self::ImageConvertColorF32 => 350,
			Self::ImageResizeNormalizeF32 => 351,
			Self::ImageSegmentationOverlayF32 => 352,
			Self::VisionBoxIouF32 => 353,
			Self::VisionNmsF32 => 354,
			Self::VisionConfusionMatrixI32 => 355,
			Self::VisionBinaryMaskCountsU8 => 356,
			Self::VisionDetectionMetricCurvesF32 => 357,
			Self::VisionDetectionAveragePrecisionF32 => 358,
			Self::VisionDetectionMeanAveragePrecisionF32 => 359,
			Self::VisionSegmentationConfusionI32 => 360,
			Self::VisionSegmentationMetricsF32 => 361,
			Self::VisionConfusionMatrixClearU32 => 362,
			Self::VisionBinaryMaskCountsClearU32 => 363,
			Self::VisionSegmentationConfusionClearU32 => 364,
		}
	}

	pub(crate) const fn semantic_contract(self) -> Option<crate::OperationContract> {
		match self {
			Self::MatrixAddF32 => Some(crate::core::operation::matrix::ADD),
			Self::MatrixAddI32 => Some(crate::core::operation::matrix::ADD),
			Self::MatrixAddBroadcastF32 => Some(crate::core::operation::matrix::ADD),
			Self::MatrixAddBroadcastI32 => Some(crate::core::operation::matrix::ADD),
			Self::MatrixSubF32 => Some(crate::core::operation::matrix::SUB),
			Self::MatrixSubBroadcastF32 => Some(crate::core::operation::matrix::SUB),
			Self::MatrixMulF32 => Some(crate::core::operation::matrix::MUL),
			Self::MatrixMulBroadcastF32 => Some(crate::core::operation::matrix::MUL),
			Self::MatrixDivF32 => Some(crate::core::operation::matrix::DIV),
			Self::MatrixDivBroadcastF32 => Some(crate::core::operation::matrix::DIV),
			Self::MatrixScaleF32 => Some(crate::core::operation::matrix::SCALE),
			Self::MatrixNegF32 => Some(crate::core::operation::matrix::NEG),
			Self::MatrixAbsF32 => Some(crate::core::operation::matrix::ABS),
			Self::MatrixLogF32 => Some(crate::core::operation::matrix::LOG),
			Self::MatrixSqrtF32 => Some(crate::core::operation::matrix::SQRT),
			Self::MatrixPowF32 => Some(crate::core::operation::matrix::POW),
			Self::MatrixAddScalarF32 => Some(crate::core::operation::matrix::ADD_SCALAR),
			Self::MatrixSubScalarF32 => Some(crate::core::operation::matrix::SUB_SCALAR),
			Self::MatrixDivScalarF32 => Some(crate::core::operation::matrix::DIV_SCALAR),
			Self::MatrixExpF32 => Some(crate::core::operation::matrix::EXP),
			Self::MatrixSinF32 => Some(crate::core::operation::matrix::SIN),
			Self::MatrixCosF32 => Some(crate::core::operation::matrix::COS),
			Self::MatrixReciprocalF32 => Some(crate::core::operation::matrix::RECIPROCAL),
			Self::MatrixClampMaxF32 => Some(crate::core::operation::matrix::CLAMP_MAX),
			Self::MatrixClampMinF32 => Some(crate::core::operation::matrix::CLAMP_MIN),
			Self::MatrixCopyF32 => Some(crate::core::operation::matrix::COPY),
			Self::MatrixCopyU8 => Some(crate::core::operation::matrix::COPY),
			Self::MatrixCopyI32 => Some(crate::core::operation::matrix::COPY),
			Self::MatrixCopyU32 => Some(crate::core::operation::matrix::COPY),
			Self::MatrixMatMulNtTiledF32 => Some(crate::core::operation::matrix::MAT_MUL_NT),
			Self::MatrixSoftmaxF32 => Some(crate::core::operation::matrix::SOFTMAX),
			Self::MatrixSoftmaxBackwardF32 => Some(crate::core::operation::matrix::SOFTMAX_BACKWARD),
			Self::MatrixLogSoftmaxF32 => Some(crate::core::operation::matrix::LOG_SOFTMAX),
			Self::MatrixLogSoftmaxBackwardF32 => {
				Some(crate::core::operation::matrix::LOG_SOFTMAX_BACKWARD)
			}
			Self::MatrixSumF32 => Some(crate::core::operation::matrix::SUM),
			Self::MatrixSumAxisF32 => Some(crate::core::operation::matrix::SUM),
			Self::MatrixSumBackwardF32 => Some(crate::core::operation::matrix::SUM_BACKWARD),
			Self::MatrixCategoricalAccuracyCountF32 => {
				Some(crate::core::operation::matrix::CATEGORICAL_ACCURACY_COUNT)
			}
			Self::MatrixMaskedCategoricalAccuracyCountF32 => {
				Some(crate::core::operation::matrix::MASKED_CATEGORICAL_ACCURACY_COUNT)
			}
			Self::MatrixPhiloxUniformF32 => Some(crate::core::operation::matrix::PHILOX_UNIFORM),
			Self::MatrixPhiloxNormalF32 => Some(crate::core::operation::matrix::PHILOX_NORMAL),
			Self::MatrixPhiloxUniformReplayF32 => Some(crate::core::operation::matrix::PHILOX_UNIFORM),
			Self::MatrixPhiloxNormalReplayF32 => Some(crate::core::operation::matrix::PHILOX_NORMAL),
			Self::MatrixPhiloxReplayAdvanceU32 => {
				Some(crate::core::operation::matrix::PHILOX_REPLAY_ADVANCE)
			}
			Self::MatrixDropoutF32 => Some(crate::core::operation::matrix::DROPOUT),
			Self::MatrixDropoutBackwardF32 => Some(crate::core::operation::matrix::DROPOUT_BACKWARD),
			Self::MatrixSampleLogitsGreedyF32 => Some(crate::core::operation::matrix::SAMPLE_LOGITS),
			Self::MatrixSampleLogitsDenseF32 => Some(crate::core::operation::matrix::SAMPLE_LOGITS),
			Self::MatrixSampleLogitsSortedF32 => Some(crate::core::operation::matrix::SAMPLE_LOGITS),
			Self::MatrixDropoutReplayF32 => Some(crate::core::operation::matrix::DROPOUT),
			Self::MatrixDropoutBackwardReplayF32 => {
				Some(crate::core::operation::matrix::DROPOUT_BACKWARD)
			}
			Self::MatrixTopKF32 => Some(crate::core::operation::matrix::TOP_K),
			Self::MatrixTopKMaskF32 => Some(crate::core::operation::matrix::TOP_K_MASK),
			Self::MatrixMoeExpertPlanU32 => Some(crate::core::operation::matrix::MOE_EXPERT_PLAN),
			Self::MatrixMoeRoutingBiasUpdateF32 => {
				Some(crate::core::operation::matrix::MOE_ROUTING_BIAS_UPDATE)
			}
			Self::MatrixSliceF32 => Some(crate::core::operation::matrix::SLICE),
			Self::MatrixSliceBackwardF32 => Some(crate::core::operation::matrix::SLICE_BACKWARD),
			Self::MatrixRepeatInterleaveF32 => Some(crate::core::operation::matrix::REPEAT_INTERLEAVE),
			Self::MatrixRepeatInterleaveBackwardF32 => {
				Some(crate::core::operation::matrix::REPEAT_INTERLEAVE_BACKWARD)
			}
			Self::MatrixGatherF32 => Some(crate::core::operation::matrix::GATHER),
			Self::MatrixGatherBackwardF32 => Some(crate::core::operation::matrix::GATHER_BACKWARD),
			Self::MatrixGatherLastDimF32 => Some(crate::core::operation::matrix::GATHER_LAST_DIM),
			Self::MatrixGatherLastDimBackwardF32 => {
				Some(crate::core::operation::matrix::GATHER_LAST_DIM_BACKWARD)
			}
			Self::MatrixConcatF32 => Some(crate::core::operation::matrix::CONCAT),
			Self::MatrixTransposeF32 => Some(crate::core::operation::matrix::TRANSPOSE),
			Self::MatrixEqualF32 => Some(crate::core::operation::matrix::EQUAL),
			Self::MlPpoClippedPolicyF32 => Some(crate::core::operation::ml::PPO_CLIPPED_POLICY),
			Self::MlPpoClippedPolicyBackwardF32 => {
				Some(crate::core::operation::ml::PPO_CLIPPED_POLICY_BACKWARD)
			}
			Self::MlLinearF32 => Some(crate::core::operation::ml::LINEAR),
			Self::MlLinearBackwardF32 => Some(crate::core::operation::ml::LINEAR_BACKWARD),
			Self::MlLinearParameterBackwardF32 => {
				Some(crate::core::operation::ml::LINEAR_PARAMETER_BACKWARD)
			}
			Self::MlCrossEntropyF32 => Some(crate::core::operation::ml::CROSS_ENTROPY),
			Self::MlCrossEntropySumF32 => None,
			Self::MlCrossEntropyBackwardF32 => Some(crate::core::operation::ml::CROSS_ENTROPY_BACKWARD),
			Self::MlMaskedCrossEntropyF32 => Some(crate::core::operation::ml::MASKED_CROSS_ENTROPY),
			Self::MlMaskedCrossEntropyBackwardF32 => {
				Some(crate::core::operation::ml::MASKED_CROSS_ENTROPY_BACKWARD)
			}
			Self::MlSmoothL1F32 => Some(crate::core::operation::ml::SMOOTH_L1),
			Self::MlSmoothL1BackwardF32 => Some(crate::core::operation::ml::SMOOTH_L1_BACKWARD),
			Self::MlSmoothL1MeanF32 => Some(crate::core::operation::ml::SMOOTH_L1),
			Self::MlMseF32 => Some(crate::core::operation::ml::MSE),
			Self::MlMseBackwardF32 => Some(crate::core::operation::ml::MSE_BACKWARD),
			Self::MlL1F32 => Some(crate::core::operation::ml::L1),
			Self::MlL1BackwardF32 => Some(crate::core::operation::ml::L1_BACKWARD),
			Self::MlBceF32 => Some(crate::core::operation::ml::BCE),
			Self::MlBceBackwardF32 => Some(crate::core::operation::ml::BCE_BACKWARD),
			Self::MlSgdF32 => Some(crate::core::operation::ml::SGD),
			Self::MlClipGradNormReduceF32 => Some(crate::core::operation::ml::CLIP_GRAD_NORM),
			Self::MlClipGradNormScaleF32 => Some(crate::core::operation::ml::CLIP_GRAD_NORM),
			Self::MlSgdMomentumF32 => Some(crate::core::operation::ml::SGD_MOMENTUM),
			Self::MlAdamF32 => Some(crate::core::operation::ml::ADAM),
			Self::MlMuonNesterovF32 => Some(crate::core::operation::ml::MUON),
			Self::MlMuonVectorF32 => Some(crate::core::operation::ml::MUON),
			Self::MlMuonNormalizeF32 => None,
			Self::MlMuonMatMulAxpbyF32 => None,
			Self::MlMuonLinearCombinationF32 => None,
			Self::MlMuonTransposeF32 => None,
			Self::MlMuonApplyF32 => None,
			Self::MlAdamWF32 => Some(crate::core::operation::ml::ADAMW),
			Self::MlAdamWGraphAdvanceU32 => Some(crate::core::operation::ml::ADAMW_GRAPH_ADVANCE),
			Self::MlAdamWGraphF32 => Some(crate::core::operation::ml::ADAMW_GRAPH),
			Self::MlEmbeddingF32 => Some(crate::core::operation::ml::EMBEDDING),
			Self::MlEmbeddingBackwardF32 => Some(crate::core::operation::ml::EMBEDDING_BACKWARD),
			Self::MlChannelNormF32 => Some(crate::core::operation::ml::CHANNEL_NORM),
			Self::MlChannelNormBackwardF32 => Some(crate::core::operation::ml::CHANNEL_NORM_BACKWARD),
			Self::MlChannelNormReluF32 => Some(crate::core::operation::ml::CHANNEL_NORM_RELU),
			Self::MlChannelNormReluBackwardF32 => {
				Some(crate::core::operation::ml::CHANNEL_NORM_RELU_BACKWARD)
			}
			Self::MlEmbeddingU8F32 => Some(crate::core::operation::ml::EMBEDDING),
			Self::MlEmbeddingBackwardU8F32 => Some(crate::core::operation::ml::EMBEDDING_BACKWARD),
			Self::MlRnnScanF32 => Some(crate::core::operation::ml::RNN_SCAN),
			Self::MlRnnScanBackwardF32 => Some(crate::core::operation::ml::RNN_SCAN_BACKWARD),
			Self::MlLayerNormF32 => Some(crate::core::operation::ml::LAYER_NORM),
			Self::MlLayerNormBackwardF32 => Some(crate::core::operation::ml::LAYER_NORM_BACKWARD),
			Self::MlRmsNormF32 => Some(crate::core::operation::ml::RMS_NORM),
			Self::MlRmsNormBackwardF32 => Some(crate::core::operation::ml::RMS_NORM_BACKWARD),
			Self::MlGeluF32 => Some(crate::core::operation::ml::GELU),
			Self::MlGeluBackwardF32 => Some(crate::core::operation::ml::GELU_BACKWARD),
			Self::MlSiluF32 => Some(crate::core::operation::ml::SILU),
			Self::MlSiluBackwardF32 => Some(crate::core::operation::ml::SILU_BACKWARD),
			Self::MlReluF32 => Some(crate::core::operation::ml::RELU),
			Self::MlReluBackwardF32 => Some(crate::core::operation::ml::RELU_BACKWARD),
			Self::MlTanhF32 => Some(crate::core::operation::ml::TANH),
			Self::MlTanhBackwardF32 => Some(crate::core::operation::ml::TANH_BACKWARD),
			Self::MlSigmoidF32 => Some(crate::core::operation::ml::SIGMOID),
			Self::MlSigmoidBackwardF32 => Some(crate::core::operation::ml::SIGMOID_BACKWARD),
			Self::MlLeakyReluF32 => Some(crate::core::operation::ml::LEAKY_RELU),
			Self::MlLeakyReluBackwardF32 => Some(crate::core::operation::ml::LEAKY_RELU_BACKWARD),
			Self::MlEluF32 => Some(crate::core::operation::ml::ELU),
			Self::MlEluBackwardF32 => Some(crate::core::operation::ml::ELU_BACKWARD),
			Self::MlMishF32 => Some(crate::core::operation::ml::MISH),
			Self::MlMishBackwardF32 => Some(crate::core::operation::ml::MISH_BACKWARD),
			Self::MlSoftplusF32 => Some(crate::core::operation::ml::SOFTPLUS),
			Self::MlSoftplusBackwardF32 => Some(crate::core::operation::ml::SOFTPLUS_BACKWARD),
			Self::MlQkvProjectionBiasF32 => None,
			Self::MlSwigluF32 => Some(crate::core::operation::ml::SWIGLU),
			Self::MlSwigluBackwardF32 => Some(crate::core::operation::ml::SWIGLU_BACKWARD),
			Self::MlGateUpSwigluBiasF32 => None,
			Self::MlAdamWMany4F32 => None,
			Self::MlAdamWMany4GraphF32 => None,
			Self::MlRopeF32 => Some(crate::core::operation::ml::ROPE),
			Self::MlRopeBackwardF32 => Some(crate::core::operation::ml::ROPE_BACKWARD),
			Self::MlAvgPool2dF32 => Some(crate::core::operation::ml::AVG_POOL_2D),
			Self::MlAvgPool2dBackwardF32 => Some(crate::core::operation::ml::AVG_POOL_2D_BACKWARD),
			Self::MlMaxPool2dF32 => Some(crate::core::operation::ml::MAX_POOL_2D),
			Self::MlMaxPool2dBackwardF32 => Some(crate::core::operation::ml::MAX_POOL_2D_BACKWARD),
			Self::MlAdaptiveAvgPool2dF32 => Some(crate::core::operation::ml::ADAPTIVE_AVG_POOL_2D),
			Self::MlAdaptiveAvgPool2dBackwardF32 => {
				Some(crate::core::operation::ml::ADAPTIVE_AVG_POOL_2D_BACKWARD)
			}
			Self::MlBatchNorm2dF32 => Some(crate::core::operation::ml::BATCH_NORM_2D),
			Self::MlBatchNorm2dWithStatsF32 => Some(crate::core::operation::ml::BATCH_NORM_2D_WITH_STATS),
			Self::MlBatchNorm2dRunningUpdateF32 => {
				Some(crate::core::operation::ml::BATCH_NORM_2D_RUNNING_UPDATE)
			}
			Self::MlBatchNorm2dBackwardF32 => Some(crate::core::operation::ml::BATCH_NORM_2D_BACKWARD),
			Self::MlBatchNorm2dInputBackwardF32 => None,
			Self::MlUpsample2dNearestF32 => Some(crate::core::operation::ml::UPSAMPLE_2D),
			Self::MlUpsample2dBilinearF32 => Some(crate::core::operation::ml::UPSAMPLE_2D),
			Self::MlUpsample2dNearestBackwardF32 => {
				Some(crate::core::operation::ml::UPSAMPLE_2D_BACKWARD)
			}
			Self::MlUpsample2dBilinearBackwardF32 => {
				Some(crate::core::operation::ml::UPSAMPLE_2D_BACKWARD)
			}
			Self::MlConv2dF32 => Some(crate::core::operation::ml::CONV_2D),
			Self::MlConv2dBackwardF32 => Some(crate::core::operation::ml::CONV_2D_BACKWARD),
			Self::MlConv2dParameterBackwardF32 => Some(crate::core::operation::ml::CONV_2D_BACKWARD),
			Self::MlConv1dIm2ColF32 => Some(crate::core::operation::ml::CONV_1D),
			Self::MlConv1dBiasAddF32 => Some(crate::core::operation::ml::CONV_1D),
			Self::MlConv1dTransposeF32 => Some(crate::core::operation::ml::CONV_1D),
			Self::MlConv1dBackwardF32 => Some(crate::core::operation::ml::CONV_1D_BACKWARD),
			Self::MlConv1dParameterBackwardF32 => Some(crate::core::operation::ml::CONV_1D_BACKWARD),
			Self::MlConvTranspose1dF32 => Some(crate::core::operation::ml::CONV_TRANSPOSE_1D),
			Self::MlConvTranspose1dBackwardF32 => {
				Some(crate::core::operation::ml::CONV_TRANSPOSE_1D_BACKWARD)
			}
			Self::MlConvTranspose2dF32 => Some(crate::core::operation::ml::CONV_TRANSPOSE_2D),
			Self::MlConvTranspose2dBiasAddF32 => Some(crate::core::operation::ml::CONV_TRANSPOSE_2D),
			Self::MlConvTranspose2dBackwardF32 => {
				Some(crate::core::operation::ml::CONV_TRANSPOSE_2D_BACKWARD)
			}
			Self::MlConvTranspose2dParameterBackwardF32 => {
				Some(crate::core::operation::ml::CONV_TRANSPOSE_2D_BACKWARD)
			}
			Self::MlGruScanF32 => Some(crate::core::operation::ml::GRU_SCAN),
			Self::MlGruScanBackwardF32 => Some(crate::core::operation::ml::GRU_SCAN_BACKWARD),
			Self::MlGruCellF32 => Some(crate::core::operation::ml::GRU_CELL),
			Self::MlGruCellBackwardF32 => Some(crate::core::operation::ml::GRU_CELL_BACKWARD),
			Self::MlRnnCellF32 => Some(crate::core::operation::ml::RNN_CELL),
			Self::MlRnnCellBackwardF32 => Some(crate::core::operation::ml::RNN_CELL_BACKWARD),
			Self::MlBmmF32 => Some(crate::core::operation::ml::BMM),
			Self::MlBmmTiled16F32 => Some(crate::core::operation::ml::BMM),
			Self::MlBmmNtF32 => Some(crate::core::operation::ml::BMM_NT),
			Self::MlBmmNtTiled16F32 => Some(crate::core::operation::ml::BMM_NT),
			Self::MlBmmTnF32 => Some(crate::core::operation::ml::BMM_TN),
			Self::MlBmmTnTiled16F32 => Some(crate::core::operation::ml::BMM_TN),
			Self::MlSplitHeadsF32 => Some(crate::core::operation::ml::SPLIT_HEADS),
			Self::MlMergeHeadsF32 => Some(crate::core::operation::ml::MERGE_HEADS),
			Self::MlSoftmaxScaledMaskedF32 => Some(crate::core::operation::ml::SOFTMAX_SCALED_MASKED),
			Self::MlSoftmaxScaledMaskedN32F32 => Some(crate::core::operation::ml::SOFTMAX_SCALED_MASKED),
			Self::MlSoftmaxScaledMaskedBackwardF32 => {
				Some(crate::core::operation::ml::SOFTMAX_SCALED_MASKED_BACKWARD)
			}
			Self::MlSdpaSoftmaxF32 => Some(crate::core::operation::ml::SCALED_DOT_PRODUCT_ATTENTION),
			Self::MlSdpaSoftmaxN32F32 => Some(crate::core::operation::ml::SCALED_DOT_PRODUCT_ATTENTION),
			Self::MlFlashAttentionCausalF32 => {
				Some(crate::core::operation::ml::SCALED_DOT_PRODUCT_ATTENTION)
			}
			Self::MlFlashAttentionCausalBackwardQF32 => {
				Some(crate::core::operation::ml::SCALED_DOT_PRODUCT_ATTENTION_BACKWARD)
			}
			Self::MlFlashAttentionCausalBackwardKvF32 => {
				Some(crate::core::operation::ml::SCALED_DOT_PRODUCT_ATTENTION_BACKWARD)
			}
			Self::MlMoeRouteWeightsF32 => Some(crate::core::operation::ml::MOE_ROUTE_WEIGHTS),
			Self::MlMoeRouteWeightsBackwardF32 => {
				Some(crate::core::operation::ml::MOE_ROUTE_WEIGHTS_BACKWARD)
			}
			Self::MlMoeGatherF32 => Some(crate::core::operation::ml::MOE_GATHER),
			Self::MlMoeGatherBackwardF32 => Some(crate::core::operation::ml::MOE_GATHER_BACKWARD),
			Self::MlMoeCombineF32 => Some(crate::core::operation::ml::MOE_COMBINE),
			Self::MlMoeCombineBackwardF32 => Some(crate::core::operation::ml::MOE_COMBINE_BACKWARD),
			Self::MlGroupedLinearMF32 => Some(crate::core::operation::ml::GROUPED_LINEAR_M),
			Self::MlGroupedLinearMDataBackwardF32 => {
				Some(crate::core::operation::ml::GROUPED_LINEAR_M_BACKWARD)
			}
			Self::MlGroupedLinearMParameterBackwardF32 => {
				Some(crate::core::operation::ml::GROUPED_LINEAR_M_BACKWARD)
			}
			Self::MlSiluMulF32 => Some(crate::core::operation::ml::SILU_MUL),
			Self::MlSiluMulBackwardF32 => Some(crate::core::operation::ml::SILU_MUL_BACKWARD),
			Self::MlGroupedGemmMF32 => Some(crate::core::operation::ml::GROUPED_GEMM_M),
			Self::MlGroupedGemmMDataBackwardF32 => {
				Some(crate::core::operation::ml::GROUPED_GEMM_M_BACKWARD)
			}
			Self::MlGroupedGemmMParameterBackwardF32 => {
				Some(crate::core::operation::ml::GROUPED_GEMM_M_BACKWARD)
			}
			Self::MlFlowLinearMatchF32 => Some(crate::core::operation::ml::LINEAR_MATCH),
			Self::MlFlowEulerStepF32 => Some(crate::core::operation::ml::EULER_STEP),
			Self::MlFlowMaskedMseF32 => Some(crate::core::operation::ml::MASKED_MSE),
			Self::MlFlowMaskedMseBackwardF32 => Some(crate::core::operation::ml::MASKED_MSE_BACKWARD),
			Self::MlGaeF32 => Some(crate::core::operation::ml::GAE),
			Self::MlRolloutAppendF32 => Some(crate::core::operation::ml::APPEND),
			Self::MlRolloutResetU8 => Some(crate::core::operation::ml::RESET),
			Self::MlReplayAppendBatchF32 => Some(crate::core::operation::ml::APPEND_BATCH),
			Self::MlReplaySampleF32 => Some(crate::core::operation::ml::SAMPLE),
			Self::MlDqnTargetF32 => Some(crate::core::operation::ml::DQN),
			Self::MlSacTargetF32 => Some(crate::core::operation::ml::SAC_CRITIC),
			Self::MlCartPoleResetF32 => Some(crate::core::operation::ml::CART_POLE_RESET),
			Self::MlCartPoleStepF32 => Some(crate::core::operation::ml::CART_POLE_STEP),
			Self::MlLunarLanderResetF32 => Some(crate::core::operation::ml::LUNAR_LANDER_RESET),
			Self::MlLunarLanderStepF32 => Some(crate::core::operation::ml::LUNAR_LANDER_STEP),
			Self::MlRmsNormGatedF32 => Some(crate::core::operation::ml::RMS_NORM_GATED),
			Self::MlRmsNormGatedBackwardF32 => Some(crate::core::operation::ml::RMS_NORM_GATED_BACKWARD),
			Self::MlMamba3PreprocessF32 => Some(crate::core::operation::ml::MAMBA3_PREPROCESS),
			Self::MlMamba3PreprocessBackwardF32 => {
				Some(crate::core::operation::ml::MAMBA3_PREPROCESS_BACKWARD)
			}
			Self::MlMamba3PreprocessBackwardReduceF32 => {
				Some(crate::core::operation::ml::MAMBA3_PREPROCESS_BACKWARD)
			}
			Self::MlMamba3SisoF32 => Some(crate::core::operation::ml::MAMBA3_SISO),
			Self::MlMamba3SisoBackwardPrepareF32 => {
				Some(crate::core::operation::ml::MAMBA3_SISO_BACKWARD)
			}
			Self::MlMamba3SisoStepF32 => Some(crate::core::operation::ml::MAMBA3_SISO_STEP),
			Self::MlMamba3SisoBackwardStateF32 => Some(crate::core::operation::ml::MAMBA3_SISO_BACKWARD),
			Self::MlMamba3SisoBackwardReverseP16F32 => {
				Some(crate::core::operation::ml::MAMBA3_SISO_BACKWARD)
			}
			Self::MlMamba3SisoBackwardFinalizeF32 => {
				Some(crate::core::operation::ml::MAMBA3_SISO_BACKWARD)
			}
			Self::MlMamba3SisoBackwardReduceF32 => Some(crate::core::operation::ml::MAMBA3_SISO_BACKWARD),
			Self::MlMamba3SisoBackwardGroupReduceF32 => {
				Some(crate::core::operation::ml::MAMBA3_SISO_BACKWARD)
			}
			Self::MlMamba3MimoF32 => Some(crate::core::operation::ml::MAMBA3_MIMO),
			Self::MlMamba3MimoBackwardCoreF32 => Some(crate::core::operation::ml::MAMBA3_MIMO_BACKWARD),
			Self::MlMamba3MimoStepF32 => Some(crate::core::operation::ml::MAMBA3_MIMO_STEP),
			Self::MlMamba3MimoBackwardPrepareF32 => {
				Some(crate::core::operation::ml::MAMBA3_MIMO_BACKWARD)
			}
			Self::MlMamba3MimoBackwardPostF32 => Some(crate::core::operation::ml::MAMBA3_MIMO_BACKWARD),
			Self::MlMamba3MimoBackwardRotateF32 => Some(crate::core::operation::ml::MAMBA3_MIMO_BACKWARD),
			Self::MlMamba3MimoBackwardReduceF32 => Some(crate::core::operation::ml::MAMBA3_MIMO_BACKWARD),
			Self::MlMamba3SisoBackwardGenericF32 => {
				Some(crate::core::operation::ml::MAMBA3_SISO_BACKWARD)
			}
			Self::MlMamba3SisoBackwardGenericReduceF32 => {
				Some(crate::core::operation::ml::MAMBA3_SISO_BACKWARD)
			}
			Self::MlMamba3SisoChunkSummaryF32 => Some(crate::core::operation::ml::MAMBA3_SISO_BACKWARD),
			Self::MlMamba3SisoChunkPrefixF32 => Some(crate::core::operation::ml::MAMBA3_SISO_BACKWARD),
			Self::MlMamba3SisoChunkDpreF32 => Some(crate::core::operation::ml::MAMBA3_SISO_BACKWARD),
			Self::MlMamba3SisoChunkBackwardSummaryF32 => {
				Some(crate::core::operation::ml::MAMBA3_SISO_BACKWARD)
			}
			Self::MlMamba3SisoChunkBackwardPrefixF32 => {
				Some(crate::core::operation::ml::MAMBA3_SISO_BACKWARD)
			}
			Self::MlMamba3SisoChunkBackwardF32 => Some(crate::core::operation::ml::MAMBA3_SISO_BACKWARD),
			Self::MlMamba3SisoChunkFinalizeF32 => Some(crate::core::operation::ml::MAMBA3_SISO_BACKWARD),
			Self::MlMamba3SisoChunkReduceF32 => Some(crate::core::operation::ml::MAMBA3_SISO_BACKWARD),
			Self::MlVqAssignF32 => Some(crate::core::operation::ml::VQ_ASSIGN),
			Self::MlVqLookupF32 => Some(crate::core::operation::ml::VQ_LOOKUP),
			Self::MlVqEmaUpdateF32 => Some(crate::core::operation::ml::VQ_EMA_UPDATE),
			Self::AudioGainF32 => Some(crate::core::operation::audio::GAIN),
			Self::AudioClipF32 => Some(crate::core::operation::audio::CLIP),
			Self::AudioSaturateF32 => Some(crate::core::operation::audio::SATURATE),
			Self::AudioResampleF32 => Some(crate::core::operation::audio::RESAMPLE),
			Self::AudioFadeF32 => Some(crate::core::operation::audio::FADE),
			Self::AudioMixF32 => Some(crate::core::operation::audio::MIX),
			Self::AudioAmplitudeToDbF32 => Some(crate::core::operation::audio::AMPLITUDE_TO_DB),
			Self::AudioWaveformEnvelopeF32 => Some(crate::core::operation::audio::WAVEFORM_ENVELOPE),
			Self::AudioPreEmphasisF32 => Some(crate::core::operation::audio::PRE_EMPHASIS),
			Self::AudioToMonoF32 => Some(crate::core::operation::audio::TO_MONO),
			Self::AudioNormalizeLevelF32 => None,
			Self::AudioNormalizeApplyF32 => None,
			Self::AudioBiquadSummaryF32 => None,
			Self::AudioBiquadScanF32 => None,
			Self::AudioBiquadApplyF32 => None,
			Self::AudioReverbCombF32 => None,
			Self::AudioReverbSumF32 => None,
			Self::AudioReverbAllpassF32 => None,
			Self::AudioReverbMixF32 => None,
			Self::AudioStftF32 => Some(crate::core::operation::audio::STFT),
			Self::AudioMelFilterbankF32 => None,
			Self::AudioMelNormalizeF32 => None,
			Self::AudioMfccDctF32 => None,
			Self::AudioSosFilterF32 => Some(crate::core::operation::audio::SOS_FILTER),
			Self::CryptographyShake128U8 => Some(crate::core::operation::cryptography::hash::SHAKE128),
			Self::CryptographyShake256U8 => Some(crate::core::operation::cryptography::hash::SHAKE256),
			Self::CryptographyKeccakF1600U8 => {
				Some(crate::core::operation::cryptography::hash::KECCAK_F1600)
			}
			Self::CryptographyMerkleReduceU8 => {
				Some(crate::core::operation::cryptography::hash::MERKLE_ROOT)
			}
			Self::CryptographyMerkleCopyU8 => {
				Some(crate::core::operation::cryptography::hash::MERKLE_ROOT)
			}
			Self::CryptographyMlDsa65VerifyU8 => {
				Some(crate::core::operation::cryptography::pqc::ML_DSA_65_VERIFY_BATCH)
			}
			Self::CryptographyMlDsa44VerifyU8 => {
				Some(crate::core::operation::cryptography::pqc::ML_DSA_44_VERIFY_BATCH)
			}
			Self::CryptographyMlDsa87VerifyU8 => {
				Some(crate::core::operation::cryptography::pqc::ML_DSA_87_VERIFY_BATCH)
			}
			Self::CryptographyMlDsa65VerifyPrehashedU8 => {
				Some(crate::core::operation::cryptography::pqc::ML_DSA_65_VERIFY_PREHASHED_BATCH)
			}
			Self::CryptographyMlDsa44VerifyPrehashedU8 => {
				Some(crate::core::operation::cryptography::pqc::ML_DSA_44_VERIFY_PREHASHED_BATCH)
			}
			Self::CryptographyMlDsa87VerifyPrehashedU8 => {
				Some(crate::core::operation::cryptography::pqc::ML_DSA_87_VERIFY_PREHASHED_BATCH)
			}
			Self::CryptographyMlDsa65VerifyHashMessageU8 => {
				Some(crate::core::operation::cryptography::pqc::ML_DSA_65_VERIFY_HASH_MESSAGE_BATCH)
			}
			Self::CryptographyMlDsa44VerifyHashMessageU8 => {
				Some(crate::core::operation::cryptography::pqc::ML_DSA_44_VERIFY_HASH_MESSAGE_BATCH)
			}
			Self::CryptographyMlDsa87VerifyHashMessageU8 => {
				Some(crate::core::operation::cryptography::pqc::ML_DSA_87_VERIFY_HASH_MESSAGE_BATCH)
			}
			Self::CryptographyMlKemKeygenU8 => None,
			Self::CryptographyMlKemEncapsU8 => None,
			Self::CryptographyMlKemDecapsU8 => None,
			Self::CryptographyMlDsaKeygenU8 => None,
			Self::CryptographyMlDsaSignU8 => None,
			Self::CryptographyMlDsaSignMessageU8 => None,
			Self::CryptographyMlDsaSignPrehashedU8 => None,
			Self::CryptographyMlDsaSignHashMessageU8 => None,
			Self::ImageResizeNearestF32 => Some(crate::core::operation::image::RESIZE),
			Self::ImageResizeBilinearF32 => Some(crate::core::operation::image::RESIZE),
			Self::ImageCropF32 => Some(crate::core::operation::image::CROP),
			Self::ImageFlipF32 => Some(crate::core::operation::image::FLIP),
			Self::ImageRotateF32 => Some(crate::core::operation::image::ROTATE),
			Self::ImagePadF32 => Some(crate::core::operation::image::PAD),
			Self::ImageCenterCropF32 => Some(crate::core::operation::image::CENTER_CROP),
			Self::ImageRemapF32 => Some(crate::core::operation::image::REMAP),
			Self::ImageWarpAffineF32 => Some(crate::core::operation::image::WARP_AFFINE),
			Self::ImageWarpPerspectiveF32 => Some(crate::core::operation::image::WARP_PERSPECTIVE),
			Self::ImageThresholdBinaryF32 => Some(crate::core::operation::image::THRESHOLD_BINARY),
			Self::ImageThresholdBinaryInvF32 => Some(crate::core::operation::image::THRESHOLD_BINARY_INV),
			Self::ImageThresholdTruncateF32 => Some(crate::core::operation::image::THRESHOLD_TRUNCATE),
			Self::ImageThresholdToZeroF32 => Some(crate::core::operation::image::THRESHOLD_TO_ZERO),
			Self::ImageThresholdToZeroInvF32 => {
				Some(crate::core::operation::image::THRESHOLD_TO_ZERO_INV)
			}
			Self::ImageInRangeF32 => Some(crate::core::operation::image::IN_RANGE),
			Self::ImageClampF32 => Some(crate::core::operation::image::CLAMP),
			Self::ImageInvertF32 => Some(crate::core::operation::image::INVERT),
			Self::ImageBrightnessContrastF32 => Some(crate::core::operation::image::BRIGHTNESS_CONTRAST),
			Self::ImageGammaContrastF32 => Some(crate::core::operation::image::GAMMA_CONTRAST),
			Self::ImageSolarizeF32 => Some(crate::core::operation::image::SOLARIZE),
			Self::ImagePosterizeF32 => Some(crate::core::operation::image::POSTERIZE),
			Self::ImageGrayscaleF32 => Some(crate::core::operation::image::GRAYSCALE),
			Self::ImageAlphaBlendF32 => Some(crate::core::operation::image::ALPHA_BLEND),
			Self::ImageCompositeF32 => Some(crate::core::operation::image::COMPOSITE),
			Self::ImageEraseF32 => Some(crate::core::operation::image::ERASE),
			Self::ImageColorTwistF32 => Some(crate::core::operation::image::COLOR_TWIST),
			Self::ImageChannelReorderF32 => Some(crate::core::operation::image::CHANNEL_REORDER),
			Self::ImageGaussianNoiseF32 => Some(crate::core::operation::image::GAUSSIAN_NOISE),
			Self::ImageSaltPepperNoiseF32 => Some(crate::core::operation::image::SALT_PEPPER_NOISE),
			Self::ImageConvolve2dF32 => Some(crate::core::operation::image::CONVOLVE_2D),
			Self::ImageSeparableConvolve2dF32 => {
				Some(crate::core::operation::image::SEPARABLE_CONVOLVE_2D)
			}
			Self::ImageAverageBlurF32 => Some(crate::core::operation::image::AVERAGE_BLUR),
			Self::ImageSobelF32 => Some(crate::core::operation::image::SOBEL),
			Self::ImageScharrF32 => Some(crate::core::operation::image::SCHARR),
			Self::ImageLaplacianF32 => Some(crate::core::operation::image::LAPLACIAN),
			Self::ImageErodeF32 => Some(crate::core::operation::image::ERODE),
			Self::ImageDilateF32 => Some(crate::core::operation::image::DILATE),
			Self::ImageMorphologyOpenF32 => Some(crate::core::operation::image::MORPHOLOGY_OPEN),
			Self::ImageMorphologyCloseF32 => Some(crate::core::operation::image::MORPHOLOGY_CLOSE),
			Self::ImageMorphologyGradientF32 => Some(crate::core::operation::image::MORPHOLOGY_GRADIENT),
			Self::ImageGaussianBlurF32 => Some(crate::core::operation::image::GAUSSIAN_BLUR),
			Self::ImageSharpenF32 => Some(crate::core::operation::image::SHARPEN),
			Self::ImageMedianBlurF32 => Some(crate::core::operation::image::MEDIAN_BLUR),
			Self::ImageBilateralFilterF32 => Some(crate::core::operation::image::BILATERAL_FILTER),
			Self::ImageUnsharpMaskF32 => Some(crate::core::operation::image::UNSHARP_MASK),
			Self::ImageMorphologyTopHatF32 => Some(crate::core::operation::image::MORPHOLOGY_TOP_HAT),
			Self::ImageMorphologyBlackHatF32 => Some(crate::core::operation::image::MORPHOLOGY_BLACK_HAT),
			Self::ImageAdaptiveThresholdMeanF32 => {
				Some(crate::core::operation::image::ADAPTIVE_THRESHOLD_MEAN)
			}
			Self::ImageAdaptiveThresholdGaussianF32 => {
				Some(crate::core::operation::image::ADAPTIVE_THRESHOLD_GAUSSIAN)
			}
			Self::ImageNormalizeF32 => Some(crate::core::operation::image::NORMALIZE),
			Self::ImageConvertColorF32 => Some(crate::core::operation::image::CONVERT_COLOR),
			Self::ImageResizeNormalizeF32 => Some(crate::core::operation::image::RESIZE_NORMALIZE),
			Self::ImageSegmentationOverlayF32 => {
				Some(crate::core::operation::image::SEGMENTATION_OVERLAY)
			}
			Self::VisionBoxIouF32 => Some(crate::core::operation::vision::BOX_IOU),
			Self::VisionNmsF32 => Some(crate::core::operation::vision::NMS),
			Self::VisionConfusionMatrixI32 => Some(crate::core::operation::vision::CONFUSION_MATRIX),
			Self::VisionBinaryMaskCountsU8 => Some(crate::core::operation::vision::BINARY_MASK_COUNTS),
			Self::VisionDetectionMetricCurvesF32 => Some(crate::core::operation::vision::EVALUATE),
			Self::VisionDetectionAveragePrecisionF32 => Some(crate::core::operation::vision::EVALUATE),
			Self::VisionDetectionMeanAveragePrecisionF32 => {
				Some(crate::core::operation::vision::EVALUATE)
			}
			Self::VisionSegmentationConfusionI32 => {
				Some(crate::core::operation::vision::EVALUATE_SEGMENTATION)
			}
			Self::VisionSegmentationMetricsF32 => {
				Some(crate::core::operation::vision::EVALUATE_SEGMENTATION)
			}
			Self::VisionConfusionMatrixClearU32 => Some(crate::core::operation::vision::CONFUSION_MATRIX),
			Self::VisionBinaryMaskCountsClearU32 => {
				Some(crate::core::operation::vision::BINARY_MASK_COUNTS)
			}
			Self::VisionSegmentationConfusionClearU32 => {
				Some(crate::core::operation::vision::EVALUATE_SEGMENTATION)
			}
		}
	}

	pub(crate) const fn report_name(self) -> &'static str {
		match self {
			Self::MatrixAddF32 => "matrix.add.f32",
			Self::MatrixAddI32 => "matrix.add.i32",
			Self::MatrixAddBroadcastF32 => "matrix.add_broadcast.f32",
			Self::MatrixAddBroadcastI32 => "matrix.add_broadcast_i32.i32",
			Self::MatrixSubF32 => "matrix.sub.f32",
			Self::MatrixSubBroadcastF32 => "matrix.sub_broadcast.f32",
			Self::MatrixMulF32 => "matrix.mul.f32",
			Self::MatrixMulBroadcastF32 => "matrix.mul_broadcast.f32",
			Self::MatrixDivF32 => "matrix.div.f32",
			Self::MatrixDivBroadcastF32 => "matrix.div_broadcast.f32",
			Self::MatrixScaleF32 => "matrix.scale.f32",
			Self::MatrixNegF32 => "matrix.neg.f32",
			Self::MatrixAbsF32 => "matrix.abs.f32",
			Self::MatrixLogF32 => "matrix.log.f32",
			Self::MatrixSqrtF32 => "matrix.sqrt.f32",
			Self::MatrixPowF32 => "matrix.pow.f32",
			Self::MatrixAddScalarF32 => "matrix.add_scalar.f32",
			Self::MatrixSubScalarF32 => "matrix.sub_scalar.f32",
			Self::MatrixDivScalarF32 => "matrix.div_scalar.f32",
			Self::MatrixExpF32 => "matrix.exp.f32",
			Self::MatrixSinF32 => "matrix.sin.f32",
			Self::MatrixCosF32 => "matrix.cos.f32",
			Self::MatrixReciprocalF32 => "matrix.reciprocal.f32",
			Self::MatrixClampMaxF32 => "matrix.clamp_max.f32",
			Self::MatrixClampMinF32 => "matrix.clamp_min.f32",
			Self::MatrixCopyF32 => "matrix.copy.f32",
			Self::MatrixCopyU8 => "matrix.copy.u8",
			Self::MatrixCopyI32 => "matrix.copy.i32",
			Self::MatrixCopyU32 => "matrix.copy.u32",
			Self::MatrixMatMulNtTiledF32 => "matrix.mat_mul_nt.f32",
			Self::MatrixSoftmaxF32 => "matrix.softmax.f32",
			Self::MatrixSoftmaxBackwardF32 => "matrix.softmax_backward.f32",
			Self::MatrixLogSoftmaxF32 => "matrix.log_softmax.f32",
			Self::MatrixLogSoftmaxBackwardF32 => "matrix.log_softmax_backward.f32",
			Self::MatrixSumF32 => "matrix.sum.f32",
			Self::MatrixSumAxisF32 => "matrix.sum_axis.f32",
			Self::MatrixSumBackwardF32 => "matrix.sum_backward.f32",
			Self::MatrixCategoricalAccuracyCountF32 => "matrix.categorical_accuracy_count.f32",
			Self::MatrixMaskedCategoricalAccuracyCountF32 => {
				"matrix.masked_categorical_accuracy_count.f32"
			}
			Self::MatrixPhiloxUniformF32 => "matrix.philox_uniform.f32",
			Self::MatrixPhiloxNormalF32 => "matrix.philox_normal.f32",
			Self::MatrixPhiloxUniformReplayF32 => "matrix.philox_uniform_replay.f32",
			Self::MatrixPhiloxNormalReplayF32 => "matrix.philox_normal_replay.f32",
			Self::MatrixPhiloxReplayAdvanceU32 => "matrix.philox_replay_advance.u32",
			Self::MatrixDropoutF32 => "matrix.dropout.f32",
			Self::MatrixDropoutBackwardF32 => "matrix.dropout_backward.f32",
			Self::MatrixSampleLogitsGreedyF32 => "matrix.sample_logits.f32",
			Self::MatrixSampleLogitsDenseF32 => "matrix.sample_logits_dense.f32",
			Self::MatrixSampleLogitsSortedF32 => "matrix.sample_logits_sorted.f32",
			Self::MatrixDropoutReplayF32 => "matrix.dropout_replay.f32",
			Self::MatrixDropoutBackwardReplayF32 => "matrix.dropout_backward_replay.f32",
			Self::MatrixTopKF32 => "matrix.top_k.f32",
			Self::MatrixTopKMaskF32 => "matrix.top_k_mask.f32",
			Self::MatrixMoeExpertPlanU32 => "matrix.moe_expert_plan.u32",
			Self::MatrixMoeRoutingBiasUpdateF32 => "matrix.moe_routing_bias_update.f32",
			Self::MatrixSliceF32 => "matrix.slice.f32",
			Self::MatrixSliceBackwardF32 => "matrix.slice_backward.f32",
			Self::MatrixRepeatInterleaveF32 => "matrix.repeat_interleave.f32",
			Self::MatrixRepeatInterleaveBackwardF32 => "matrix.repeat_interleave_backward.f32",
			Self::MatrixGatherF32 => "matrix.gather.f32",
			Self::MatrixGatherBackwardF32 => "matrix.gather_backward.f32",
			Self::MatrixGatherLastDimF32 => "matrix.gather_last_dim.f32",
			Self::MatrixGatherLastDimBackwardF32 => "matrix.gather_last_dim_backward.f32",
			Self::MatrixConcatF32 => "matrix.concat.u32",
			Self::MatrixTransposeF32 => "matrix.transpose.f32",
			Self::MatrixEqualF32 => "matrix.equal.f32",
			Self::MlPpoClippedPolicyF32 => "ml.loss.ppo_clipped_policy.f32",
			Self::MlPpoClippedPolicyBackwardF32 => "ml.loss.ppo_clipped_policy_backward.f32",
			Self::MlLinearF32 => "ml.matrix.linear.f32",
			Self::MlLinearBackwardF32 => "ml.matrix.linear_backward.f32",
			Self::MlLinearParameterBackwardF32 => "ml.matrix.linear_parameter_backward.f32",
			Self::MlCrossEntropyF32 => "ml.loss.cross_entropy.f32",
			Self::MlCrossEntropySumF32 => "ml.cross_entropy_sum.f32",
			Self::MlCrossEntropyBackwardF32 => "ml.loss.cross_entropy_backward.f32",
			Self::MlMaskedCrossEntropyF32 => "ml.loss.masked_cross_entropy.f32",
			Self::MlMaskedCrossEntropyBackwardF32 => "ml.loss.masked_cross_entropy_backward.f32",
			Self::MlSmoothL1F32 => "ml.loss.smooth_l1.f32",
			Self::MlSmoothL1BackwardF32 => "ml.loss.smooth_l1_backward.f32",
			Self::MlSmoothL1MeanF32 => "ml.smooth_l1_mean.f32",
			Self::MlMseF32 => "ml.loss.mse.f32",
			Self::MlMseBackwardF32 => "ml.loss.mse_backward.f32",
			Self::MlL1F32 => "ml.loss.l1.f32",
			Self::MlL1BackwardF32 => "ml.loss.l1_backward.f32",
			Self::MlBceF32 => "ml.loss.bce.f32",
			Self::MlBceBackwardF32 => "ml.loss.bce_backward.f32",
			Self::MlSgdF32 => "ml.optim.sgd.f32",
			Self::MlClipGradNormReduceF32 => "ml.optim.clip_grad_norm.f32",
			Self::MlClipGradNormScaleF32 => "ml.clip_grad_norm_scale.f32",
			Self::MlSgdMomentumF32 => "ml.optim.sgd_momentum.f32",
			Self::MlAdamF32 => "ml.optim.adam.f32",
			Self::MlMuonNesterovF32 => "ml.optim.muon.f32",
			Self::MlMuonVectorF32 => "ml.muon_vector.f32",
			Self::MlMuonNormalizeF32 => "ml.muon_normalize.f32",
			Self::MlMuonMatMulAxpbyF32 => "ml.muon_mat_mul_axpby.f32",
			Self::MlMuonLinearCombinationF32 => "ml.muon_linear_combination.f32",
			Self::MlMuonTransposeF32 => "ml.muon_transpose.f32",
			Self::MlMuonApplyF32 => "ml.muon_apply.f32",
			Self::MlAdamWF32 => "ml.optim.adamw.f32",
			Self::MlAdamWGraphAdvanceU32 => "ml.optim.adamw_graph_advance.u32",
			Self::MlAdamWGraphF32 => "ml.optim.adamw_graph.f32",
			Self::MlEmbeddingF32 => "ml.matrix.embedding.f32",
			Self::MlEmbeddingBackwardF32 => "ml.matrix.embedding_backward.f32",
			Self::MlChannelNormF32 => "ml.matrix.channel_norm.f32",
			Self::MlChannelNormBackwardF32 => "ml.matrix.channel_norm_backward.f32",
			Self::MlChannelNormReluF32 => "ml.matrix.channel_norm_relu.f32",
			Self::MlChannelNormReluBackwardF32 => "ml.matrix.channel_norm_relu_backward.f32",
			Self::MlEmbeddingU8F32 => "ml.embedding_u8.f32",
			Self::MlEmbeddingBackwardU8F32 => "ml.embedding_backward_u8.f32",
			Self::MlRnnScanF32 => "ml.matrix.rnn_scan.f32",
			Self::MlRnnScanBackwardF32 => "ml.matrix.rnn_scan_backward.f32",
			Self::MlLayerNormF32 => "ml.matrix.layer_norm.f32",
			Self::MlLayerNormBackwardF32 => "ml.matrix.layer_norm_backward.f32",
			Self::MlRmsNormF32 => "ml.matrix.rms_norm.f32",
			Self::MlRmsNormBackwardF32 => "ml.matrix.rms_norm_backward.f32",
			Self::MlGeluF32 => "ml.matrix.gelu.f32",
			Self::MlGeluBackwardF32 => "ml.matrix.gelu_backward.f32",
			Self::MlSiluF32 => "ml.matrix.silu.f32",
			Self::MlSiluBackwardF32 => "ml.matrix.silu_backward.f32",
			Self::MlReluF32 => "ml.matrix.relu.f32",
			Self::MlReluBackwardF32 => "ml.matrix.relu_backward.f32",
			Self::MlTanhF32 => "ml.matrix.tanh.f32",
			Self::MlTanhBackwardF32 => "ml.matrix.tanh_backward.f32",
			Self::MlSigmoidF32 => "ml.matrix.sigmoid.f32",
			Self::MlSigmoidBackwardF32 => "ml.matrix.sigmoid_backward.f32",
			Self::MlLeakyReluF32 => "ml.matrix.leaky_relu.f32",
			Self::MlLeakyReluBackwardF32 => "ml.matrix.leaky_relu_backward.f32",
			Self::MlEluF32 => "ml.matrix.elu.f32",
			Self::MlEluBackwardF32 => "ml.matrix.elu_backward.f32",
			Self::MlMishF32 => "ml.matrix.mish.f32",
			Self::MlMishBackwardF32 => "ml.matrix.mish_backward.f32",
			Self::MlSoftplusF32 => "ml.matrix.softplus.f32",
			Self::MlSoftplusBackwardF32 => "ml.matrix.softplus_backward.f32",
			Self::MlQkvProjectionBiasF32 => "ml.qkv_projection_bias.f32",
			Self::MlSwigluF32 => "ml.matrix.swiglu.f32",
			Self::MlSwigluBackwardF32 => "ml.matrix.swiglu_backward.f32",
			Self::MlGateUpSwigluBiasF32 => "ml.gate_up_swiglu_bias.f32",
			Self::MlAdamWMany4F32 => "ml.adamw_many4.f32",
			Self::MlAdamWMany4GraphF32 => "ml.adamw_many4_graph.f32",
			Self::MlRopeF32 => "ml.matrix.rope.f32",
			Self::MlRopeBackwardF32 => "ml.matrix.rope_backward.f32",
			Self::MlAvgPool2dF32 => "ml.matrix.avg_pool_2d.f32",
			Self::MlAvgPool2dBackwardF32 => "ml.matrix.avg_pool_2d_backward.f32",
			Self::MlMaxPool2dF32 => "ml.matrix.max_pool_2d.f32",
			Self::MlMaxPool2dBackwardF32 => "ml.matrix.max_pool_2d_backward.f32",
			Self::MlAdaptiveAvgPool2dF32 => "ml.matrix.adaptive_avg_pool_2d.f32",
			Self::MlAdaptiveAvgPool2dBackwardF32 => "ml.matrix.adaptive_avg_pool_2d_backward.f32",
			Self::MlBatchNorm2dF32 => "ml.matrix.batch_norm_2d.f32",
			Self::MlBatchNorm2dWithStatsF32 => "ml.matrix.batch_norm_2d_with_stats.f32",
			Self::MlBatchNorm2dRunningUpdateF32 => "ml.matrix.batch_norm_2d_running_update.f32",
			Self::MlBatchNorm2dBackwardF32 => "ml.matrix.batch_norm_2d_backward.f32",
			Self::MlBatchNorm2dInputBackwardF32 => "ml.batch_norm_2d_input_backward.f32",
			Self::MlUpsample2dNearestF32 => "ml.matrix.upsample_2d.f32",
			Self::MlUpsample2dBilinearF32 => "ml.upsample_2d_bilinear.f32",
			Self::MlUpsample2dNearestBackwardF32 => "ml.matrix.upsample_2d_backward.f32",
			Self::MlUpsample2dBilinearBackwardF32 => "ml.upsample_2d_bilinear_backward.f32",
			Self::MlConv2dF32 => "ml.matrix.conv_2d.f32",
			Self::MlConv2dBackwardF32 => "ml.matrix.conv_2d_backward.f32",
			Self::MlConv2dParameterBackwardF32 => "ml.conv_2d_parameter_backward.f32",
			Self::MlConv1dIm2ColF32 => "ml.matrix.conv_1d.f32",
			Self::MlConv1dBiasAddF32 => "ml.conv_1d_bias_add.f32",
			Self::MlConv1dTransposeF32 => "ml.conv_1d_transpose.f32",
			Self::MlConv1dBackwardF32 => "ml.matrix.conv_1d_backward.f32",
			Self::MlConv1dParameterBackwardF32 => "ml.conv_1d_parameter_backward.f32",
			Self::MlConvTranspose1dF32 => "ml.matrix.conv_transpose_1d.f32",
			Self::MlConvTranspose1dBackwardF32 => "ml.matrix.conv_transpose_1d_backward.f32",
			Self::MlConvTranspose2dF32 => "ml.matrix.conv_transpose_2d.f32",
			Self::MlConvTranspose2dBiasAddF32 => "ml.conv_transpose_2d_bias_add.f32",
			Self::MlConvTranspose2dBackwardF32 => "ml.matrix.conv_transpose_2d_backward.f32",
			Self::MlConvTranspose2dParameterBackwardF32 => "ml.conv_transpose_2d_parameter_backward.f32",
			Self::MlGruScanF32 => "ml.matrix.gru_scan.f32",
			Self::MlGruScanBackwardF32 => "ml.matrix.gru_scan_backward.f32",
			Self::MlGruCellF32 => "ml.matrix.gru_cell.f32",
			Self::MlGruCellBackwardF32 => "ml.matrix.gru_cell_backward.f32",
			Self::MlRnnCellF32 => "ml.matrix.rnn_cell.f32",
			Self::MlRnnCellBackwardF32 => "ml.matrix.rnn_cell_backward.f32",
			Self::MlBmmF32 => "ml.matrix.bmm.f32",
			Self::MlBmmTiled16F32 => "ml.bmm_tiled_16.f32",
			Self::MlBmmNtF32 => "ml.matrix.bmm_nt.f32",
			Self::MlBmmNtTiled16F32 => "ml.bmm_nt_tiled_16.f32",
			Self::MlBmmTnF32 => "ml.matrix.bmm_tn.f32",
			Self::MlBmmTnTiled16F32 => "ml.bmm_tn_tiled_16.f32",
			Self::MlSplitHeadsF32 => "ml.matrix.split_heads.f32",
			Self::MlMergeHeadsF32 => "ml.matrix.merge_heads.f32",
			Self::MlSoftmaxScaledMaskedF32 => "ml.matrix.softmax_scaled_masked.f32",
			Self::MlSoftmaxScaledMaskedN32F32 => "ml.softmax_scaled_masked_n32.f32",
			Self::MlSoftmaxScaledMaskedBackwardF32 => "ml.matrix.softmax_scaled_masked_backward.f32",
			Self::MlSdpaSoftmaxF32 => "ml.matrix.scaled_dot_product_attention.f32",
			Self::MlSdpaSoftmaxN32F32 => "ml.sdpa_softmax_n32.f32",
			Self::MlFlashAttentionCausalF32 => "ml.flash_attention_causal.f32",
			Self::MlFlashAttentionCausalBackwardQF32 => {
				"ml.matrix.scaled_dot_product_attention_backward.f32"
			}
			Self::MlFlashAttentionCausalBackwardKvF32 => "ml.flash_attention_causal_backward_kv.f32",
			Self::MlMoeRouteWeightsF32 => "ml.matrix.moe_route_weights.f32",
			Self::MlMoeRouteWeightsBackwardF32 => "ml.matrix.moe_route_weights_backward.f32",
			Self::MlMoeGatherF32 => "ml.matrix.moe_gather.f32",
			Self::MlMoeGatherBackwardF32 => "ml.matrix.moe_gather_backward.f32",
			Self::MlMoeCombineF32 => "ml.matrix.moe_combine.f32",
			Self::MlMoeCombineBackwardF32 => "ml.matrix.moe_combine_backward.f32",
			Self::MlGroupedLinearMF32 => "ml.matrix.grouped_linear_m.f32",
			Self::MlGroupedLinearMDataBackwardF32 => "ml.matrix.grouped_linear_m_backward.f32",
			Self::MlGroupedLinearMParameterBackwardF32 => "ml.grouped_linear_m_parameter_backward.f32",
			Self::MlSiluMulF32 => "ml.matrix.silu_mul.f32",
			Self::MlSiluMulBackwardF32 => "ml.matrix.silu_mul_backward.f32",
			Self::MlGroupedGemmMF32 => "ml.matrix.grouped_gemm_m.f32",
			Self::MlGroupedGemmMDataBackwardF32 => "ml.matrix.grouped_gemm_m_backward.f32",
			Self::MlGroupedGemmMParameterBackwardF32 => "ml.grouped_gemm_m_parameter_backward.f32",
			Self::MlFlowLinearMatchF32 => "ml.flow.linear_match.f32",
			Self::MlFlowEulerStepF32 => "ml.flow.euler_step.f32",
			Self::MlFlowMaskedMseF32 => "ml.flow.masked_mse.f32",
			Self::MlFlowMaskedMseBackwardF32 => "ml.flow.masked_mse_backward.f32",
			Self::MlGaeF32 => "ml.advantage.gae.f32",
			Self::MlRolloutAppendF32 => "ml.rollout.append.f32",
			Self::MlRolloutResetU8 => "ml.rollout.reset.u8",
			Self::MlReplayAppendBatchF32 => "ml.replay.append_batch.f32",
			Self::MlReplaySampleF32 => "ml.replay.sample.f32",
			Self::MlDqnTargetF32 => "ml.dqn_target.f32",
			Self::MlSacTargetF32 => "ml.sac_target.f32",
			Self::MlCartPoleResetF32 => "ml.environment.cart_pole_reset.f32",
			Self::MlCartPoleStepF32 => "ml.environment.cart_pole_step.f32",
			Self::MlLunarLanderResetF32 => "ml.environment.lunar_lander_reset.f32",
			Self::MlLunarLanderStepF32 => "ml.environment.lunar_lander_step.f32",
			Self::MlRmsNormGatedF32 => "ml.matrix.rms_norm_gated.f32",
			Self::MlRmsNormGatedBackwardF32 => "ml.matrix.rms_norm_gated_backward.f32",
			Self::MlMamba3PreprocessF32 => "ml.matrix.mamba3_preprocess.f32",
			Self::MlMamba3PreprocessBackwardF32 => "ml.matrix.mamba3_preprocess_backward.f32",
			Self::MlMamba3PreprocessBackwardReduceF32 => "ml.mamba3_preprocess_backward_reduce.f32",
			Self::MlMamba3SisoF32 => "ml.matrix.mamba3_siso.f32",
			Self::MlMamba3SisoBackwardPrepareF32 => "ml.matrix.mamba3_siso_backward.f32",
			Self::MlMamba3SisoStepF32 => "ml.matrix.mamba3_siso_step.f32",
			Self::MlMamba3SisoBackwardStateF32 => "ml.mamba3_siso_backward_state.f32",
			Self::MlMamba3SisoBackwardReverseP16F32 => "ml.mamba3_siso_backward_reverse_p16.f32",
			Self::MlMamba3SisoBackwardFinalizeF32 => "ml.mamba3_siso_backward_finalize.f32",
			Self::MlMamba3SisoBackwardReduceF32 => "ml.mamba3_siso_backward_reduce.f32",
			Self::MlMamba3SisoBackwardGroupReduceF32 => "ml.mamba3_siso_backward_group_reduce.f32",
			Self::MlMamba3MimoF32 => "ml.matrix.mamba3_mimo.f32",
			Self::MlMamba3MimoBackwardCoreF32 => "ml.matrix.mamba3_mimo_backward.f32",
			Self::MlMamba3MimoStepF32 => "ml.matrix.mamba3_mimo_step.f32",
			Self::MlMamba3MimoBackwardPrepareF32 => "ml.mamba3_mimo_backward_prepare.f32",
			Self::MlMamba3MimoBackwardPostF32 => "ml.mamba3_mimo_backward_post.f32",
			Self::MlMamba3MimoBackwardRotateF32 => "ml.mamba3_mimo_backward_rotate.f32",
			Self::MlMamba3MimoBackwardReduceF32 => "ml.mamba3_mimo_backward_reduce.f32",
			Self::MlMamba3SisoBackwardGenericF32 => "ml.mamba3_siso_backward_generic.f32",
			Self::MlMamba3SisoBackwardGenericReduceF32 => "ml.mamba3_siso_backward_generic_reduce.f32",
			Self::MlMamba3SisoChunkSummaryF32 => "ml.mamba3_siso_chunk_summary.f32",
			Self::MlMamba3SisoChunkPrefixF32 => "ml.mamba3_siso_chunk_prefix.f32",
			Self::MlMamba3SisoChunkDpreF32 => "ml.mamba3_siso_chunk_dpre.f32",
			Self::MlMamba3SisoChunkBackwardSummaryF32 => "ml.mamba3_siso_chunk_backward_summary.f32",
			Self::MlMamba3SisoChunkBackwardPrefixF32 => "ml.mamba3_siso_chunk_backward_prefix.f32",
			Self::MlMamba3SisoChunkBackwardF32 => "ml.mamba3_siso_chunk_backward.f32",
			Self::MlMamba3SisoChunkFinalizeF32 => "ml.mamba3_siso_chunk_finalize.f32",
			Self::MlMamba3SisoChunkReduceF32 => "ml.mamba3_siso_chunk_reduce.f32",
			Self::MlVqAssignF32 => "ml.matrix.vq_assign.f32",
			Self::MlVqLookupF32 => "ml.matrix.vq_lookup.f32",
			Self::MlVqEmaUpdateF32 => "ml.matrix.vq_ema_update.f32",
			Self::AudioGainF32 => "audio.gain.f32",
			Self::AudioClipF32 => "audio.clip.f32",
			Self::AudioSaturateF32 => "audio.saturate.f32",
			Self::AudioResampleF32 => "audio.resample.f32",
			Self::AudioFadeF32 => "audio.fade.f32",
			Self::AudioMixF32 => "audio.mix.f32",
			Self::AudioAmplitudeToDbF32 => "audio.amplitude_to_db.f32",
			Self::AudioWaveformEnvelopeF32 => "audio.waveform_envelope.f32",
			Self::AudioPreEmphasisF32 => "audio.pre_emphasis.f32",
			Self::AudioToMonoF32 => "audio.to_mono.f32",
			Self::AudioNormalizeLevelF32 => "audio.normalize_level.f32",
			Self::AudioNormalizeApplyF32 => "audio.normalize_apply.f32",
			Self::AudioBiquadSummaryF32 => "audio.biquad_summary.f32",
			Self::AudioBiquadScanF32 => "audio.biquad_scan.f32",
			Self::AudioBiquadApplyF32 => "audio.biquad_apply.f32",
			Self::AudioReverbCombF32 => "audio.reverb_comb.f32",
			Self::AudioReverbSumF32 => "audio.reverb_sum.f32",
			Self::AudioReverbAllpassF32 => "audio.reverb_allpass.f32",
			Self::AudioReverbMixF32 => "audio.reverb_mix.f32",
			Self::AudioStftF32 => "audio.stft.f32",
			Self::AudioMelFilterbankF32 => "audio.mel_filterbank.f32",
			Self::AudioMelNormalizeF32 => "audio.mel_normalize.f32",
			Self::AudioMfccDctF32 => "audio.mfcc_dct.f32",
			Self::AudioSosFilterF32 => "audio.sos_filter.f32",
			Self::CryptographyShake128U8 => "cryptography.hash.shake128.u8",
			Self::CryptographyShake256U8 => "cryptography.hash.shake256.u8",
			Self::CryptographyKeccakF1600U8 => "cryptography.hash.keccak_f1600.u8",
			Self::CryptographyMerkleReduceU8 => "cryptography.hash.merkle_reduce.u8",
			Self::CryptographyMerkleCopyU8 => "cryptography.hash.merkle_copy.u8",
			Self::CryptographyMlDsa65VerifyU8 => "cryptography.pqc.ml_dsa_65_verify.u8",
			Self::CryptographyMlDsa44VerifyU8 => "cryptography.pqc.ml_dsa_44_verify.u8",
			Self::CryptographyMlDsa87VerifyU8 => "cryptography.pqc.ml_dsa_87_verify.u8",
			Self::CryptographyMlDsa65VerifyPrehashedU8 => {
				"cryptography.pqc.ml_dsa_65_verify_prehashed.u8"
			}
			Self::CryptographyMlDsa44VerifyPrehashedU8 => {
				"cryptography.pqc.ml_dsa_44_verify_prehashed.u8"
			}
			Self::CryptographyMlDsa87VerifyPrehashedU8 => {
				"cryptography.pqc.ml_dsa_87_verify_prehashed.u8"
			}
			Self::CryptographyMlDsa65VerifyHashMessageU8 => {
				"cryptography.pqc.ml_dsa_65_verify_hash_message.u8"
			}
			Self::CryptographyMlDsa44VerifyHashMessageU8 => {
				"cryptography.pqc.ml_dsa_44_verify_hash_message.u8"
			}
			Self::CryptographyMlDsa87VerifyHashMessageU8 => {
				"cryptography.pqc.ml_dsa_87_verify_hash_message.u8"
			}
			Self::CryptographyMlKemKeygenU8 => "cryptography.pqc.ml_kem_keygen.u8",
			Self::CryptographyMlKemEncapsU8 => "cryptography.pqc.ml_kem_encaps.u8",
			Self::CryptographyMlKemDecapsU8 => "cryptography.pqc.ml_kem_decaps.u8",
			Self::CryptographyMlDsaKeygenU8 => "cryptography.pqc.ml_dsa_keygen.u8",
			Self::CryptographyMlDsaSignU8 => "cryptography.pqc.ml_dsa_sign.u8",
			Self::CryptographyMlDsaSignMessageU8 => "cryptography.pqc.ml_dsa_sign_message.u8",
			Self::CryptographyMlDsaSignPrehashedU8 => "cryptography.pqc.ml_dsa_sign_prehashed.u8",
			Self::CryptographyMlDsaSignHashMessageU8 => "cryptography.pqc.ml_dsa_sign_hash_message.u8",
			Self::ImageResizeNearestF32 => "image.resize_nearest.f32",
			Self::ImageResizeBilinearF32 => "image.resize_bilinear.f32",
			Self::ImageCropF32 => "image.crop.f32",
			Self::ImageFlipF32 => "image.flip.f32",
			Self::ImageRotateF32 => "image.rotate.f32",
			Self::ImagePadF32 => "image.pad.f32",
			Self::ImageCenterCropF32 => "image.center_crop.f32",
			Self::ImageRemapF32 => "image.remap.f32",
			Self::ImageWarpAffineF32 => "image.warp_affine.f32",
			Self::ImageWarpPerspectiveF32 => "image.warp_perspective.f32",
			Self::ImageThresholdBinaryF32 => "image.threshold_binary.f32",
			Self::ImageThresholdBinaryInvF32 => "image.threshold_binary_inv.f32",
			Self::ImageThresholdTruncateF32 => "image.threshold_truncate.f32",
			Self::ImageThresholdToZeroF32 => "image.threshold_to_zero.f32",
			Self::ImageThresholdToZeroInvF32 => "image.threshold_to_zero_inv.f32",
			Self::ImageInRangeF32 => "image.in_range.f32",
			Self::ImageClampF32 => "image.clamp.f32",
			Self::ImageInvertF32 => "image.invert.f32",
			Self::ImageBrightnessContrastF32 => "image.brightness_contrast.f32",
			Self::ImageGammaContrastF32 => "image.gamma_contrast.f32",
			Self::ImageSolarizeF32 => "image.solarize.f32",
			Self::ImagePosterizeF32 => "image.posterize.f32",
			Self::ImageGrayscaleF32 => "image.grayscale.f32",
			Self::ImageAlphaBlendF32 => "image.alpha_blend.f32",
			Self::ImageCompositeF32 => "image.composite.f32",
			Self::ImageEraseF32 => "image.erase.f32",
			Self::ImageColorTwistF32 => "image.color_twist.f32",
			Self::ImageChannelReorderF32 => "image.channel_reorder.f32",
			Self::ImageGaussianNoiseF32 => "image.gaussian_noise.f32",
			Self::ImageSaltPepperNoiseF32 => "image.salt_pepper_noise.f32",
			Self::ImageConvolve2dF32 => "image.convolve_2d.f32",
			Self::ImageSeparableConvolve2dF32 => "image.separable_convolve_2d.f32",
			Self::ImageAverageBlurF32 => "image.average_blur.f32",
			Self::ImageSobelF32 => "image.sobel.f32",
			Self::ImageScharrF32 => "image.scharr.f32",
			Self::ImageLaplacianF32 => "image.laplacian.f32",
			Self::ImageErodeF32 => "image.erode.f32",
			Self::ImageDilateF32 => "image.dilate.f32",
			Self::ImageMorphologyOpenF32 => "image.morphology_open.f32",
			Self::ImageMorphologyCloseF32 => "image.morphology_close.f32",
			Self::ImageMorphologyGradientF32 => "image.morphology_gradient.f32",
			Self::ImageGaussianBlurF32 => "image.gaussian_blur.f32",
			Self::ImageSharpenF32 => "image.sharpen.f32",
			Self::ImageMedianBlurF32 => "image.median_blur.f32",
			Self::ImageBilateralFilterF32 => "image.bilateral_filter.f32",
			Self::ImageUnsharpMaskF32 => "image.unsharp_mask.f32",
			Self::ImageMorphologyTopHatF32 => "image.morphology_top_hat.f32",
			Self::ImageMorphologyBlackHatF32 => "image.morphology_black_hat.f32",
			Self::ImageAdaptiveThresholdMeanF32 => "image.adaptive_threshold_mean.f32",
			Self::ImageAdaptiveThresholdGaussianF32 => "image.adaptive_threshold_gaussian.f32",
			Self::ImageNormalizeF32 => "image.normalize.f32",
			Self::ImageConvertColorF32 => "image.convert_color.f32",
			Self::ImageResizeNormalizeF32 => "image.resize_normalize.f32",
			Self::ImageSegmentationOverlayF32 => "image.segmentation_overlay.f32",
			Self::VisionBoxIouF32 => "vision.box_iou.f32",
			Self::VisionNmsF32 => "vision.nms.f32",
			Self::VisionConfusionMatrixI32 => "vision.confusion_matrix.i32",
			Self::VisionBinaryMaskCountsU8 => "vision.binary_mask_counts.u8",
			Self::VisionDetectionMetricCurvesF32 => "vision.detection_metric_curves.f32",
			Self::VisionDetectionAveragePrecisionF32 => "vision.detection_average_precision.f32",
			Self::VisionDetectionMeanAveragePrecisionF32 => "vision.detection_mean_average_precision.f32",
			Self::VisionSegmentationConfusionI32 => "vision.segmentation_confusion.i32",
			Self::VisionSegmentationMetricsF32 => "vision.segmentation_metrics.f32",
			Self::VisionConfusionMatrixClearU32 => "vision.confusion_matrix_clear.u32",
			Self::VisionBinaryMaskCountsClearU32 => "vision.binary_mask_counts_clear.u32",
			Self::VisionSegmentationConfusionClearU32 => "vision.segmentation_confusion_clear.u32",
		}
	}

	pub(crate) const fn dtype_report_token(self) -> &'static str {
		match self {
			Self::MatrixAddF32 => "float32",
			Self::MatrixAddI32 => "int32",
			Self::MatrixAddBroadcastF32 => "float32",
			Self::MatrixAddBroadcastI32 => "int32",
			Self::MatrixSubF32 => "float32",
			Self::MatrixSubBroadcastF32 => "float32",
			Self::MatrixMulF32 => "float32",
			Self::MatrixMulBroadcastF32 => "float32",
			Self::MatrixDivF32 => "float32",
			Self::MatrixDivBroadcastF32 => "float32",
			Self::MatrixScaleF32 => "float32",
			Self::MatrixNegF32 => "float32",
			Self::MatrixAbsF32 => "float32",
			Self::MatrixLogF32 => "float32",
			Self::MatrixSqrtF32 => "float32",
			Self::MatrixPowF32 => "float32",
			Self::MatrixAddScalarF32 => "float32",
			Self::MatrixSubScalarF32 => "float32",
			Self::MatrixDivScalarF32 => "float32",
			Self::MatrixExpF32 => "float32",
			Self::MatrixSinF32 => "float32",
			Self::MatrixCosF32 => "float32",
			Self::MatrixReciprocalF32 => "float32",
			Self::MatrixClampMaxF32 => "float32",
			Self::MatrixClampMinF32 => "float32",
			Self::MatrixCopyF32 => "float32",
			Self::MatrixCopyU8 => "uint8",
			Self::MatrixCopyI32 => "int32",
			Self::MatrixCopyU32 => "uint32",
			Self::MatrixMatMulNtTiledF32 => "float32",
			Self::MatrixSoftmaxF32 => "float32",
			Self::MatrixSoftmaxBackwardF32 => "float32",
			Self::MatrixLogSoftmaxF32 => "float32",
			Self::MatrixLogSoftmaxBackwardF32 => "float32",
			Self::MatrixSumF32 => "float32",
			Self::MatrixSumAxisF32 => "float32",
			Self::MatrixSumBackwardF32 => "float32",
			Self::MatrixCategoricalAccuracyCountF32 => "float32",
			Self::MatrixMaskedCategoricalAccuracyCountF32 => "float32",
			Self::MatrixPhiloxUniformF32 => "float32",
			Self::MatrixPhiloxNormalF32 => "float32",
			Self::MatrixPhiloxUniformReplayF32 => "float32",
			Self::MatrixPhiloxNormalReplayF32 => "float32",
			Self::MatrixPhiloxReplayAdvanceU32 => "uint32",
			Self::MatrixDropoutF32 => "float32",
			Self::MatrixDropoutBackwardF32 => "float32",
			Self::MatrixSampleLogitsGreedyF32 => "float32",
			Self::MatrixSampleLogitsDenseF32 => "float32",
			Self::MatrixSampleLogitsSortedF32 => "float32",
			Self::MatrixDropoutReplayF32 => "float32",
			Self::MatrixDropoutBackwardReplayF32 => "float32",
			Self::MatrixTopKF32 => "float32",
			Self::MatrixTopKMaskF32 => "float32",
			Self::MatrixMoeExpertPlanU32 => "uint32",
			Self::MatrixMoeRoutingBiasUpdateF32 => "float32",
			Self::MatrixSliceF32 => "float32",
			Self::MatrixSliceBackwardF32 => "float32",
			Self::MatrixRepeatInterleaveF32 => "float32",
			Self::MatrixRepeatInterleaveBackwardF32 => "float32",
			Self::MatrixGatherF32 => "float32",
			Self::MatrixGatherBackwardF32 => "float32",
			Self::MatrixGatherLastDimF32 => "float32",
			Self::MatrixGatherLastDimBackwardF32 => "float32",
			Self::MatrixConcatF32 => "uint32",
			Self::MatrixTransposeF32 => "float32",
			Self::MatrixEqualF32 => "float32",
			Self::MlPpoClippedPolicyF32 => "float32",
			Self::MlPpoClippedPolicyBackwardF32 => "float32",
			Self::MlLinearF32 => "float32",
			Self::MlLinearBackwardF32 => "float32",
			Self::MlLinearParameterBackwardF32 => "float32",
			Self::MlCrossEntropyF32 => "float32",
			Self::MlCrossEntropySumF32 => "float32",
			Self::MlCrossEntropyBackwardF32 => "float32",
			Self::MlMaskedCrossEntropyF32 => "float32",
			Self::MlMaskedCrossEntropyBackwardF32 => "float32",
			Self::MlSmoothL1F32 => "float32",
			Self::MlSmoothL1BackwardF32 => "float32",
			Self::MlSmoothL1MeanF32 => "float32",
			Self::MlMseF32 => "float32",
			Self::MlMseBackwardF32 => "float32",
			Self::MlL1F32 => "float32",
			Self::MlL1BackwardF32 => "float32",
			Self::MlBceF32 => "float32",
			Self::MlBceBackwardF32 => "float32",
			Self::MlSgdF32 => "float32",
			Self::MlClipGradNormReduceF32 => "float32",
			Self::MlClipGradNormScaleF32 => "float32",
			Self::MlSgdMomentumF32 => "float32",
			Self::MlAdamF32 => "float32",
			Self::MlMuonNesterovF32 => "float32",
			Self::MlMuonVectorF32 => "float32",
			Self::MlMuonNormalizeF32 => "float32",
			Self::MlMuonMatMulAxpbyF32 => "float32",
			Self::MlMuonLinearCombinationF32 => "float32",
			Self::MlMuonTransposeF32 => "float32",
			Self::MlMuonApplyF32 => "float32",
			Self::MlAdamWF32 => "float32",
			Self::MlAdamWGraphAdvanceU32 => "uint32",
			Self::MlAdamWGraphF32 => "float32",
			Self::MlEmbeddingF32 => "float32",
			Self::MlEmbeddingBackwardF32 => "float32",
			Self::MlChannelNormF32 => "float32",
			Self::MlChannelNormBackwardF32 => "float32",
			Self::MlChannelNormReluF32 => "float32",
			Self::MlChannelNormReluBackwardF32 => "float32",
			Self::MlEmbeddingU8F32 => "float32",
			Self::MlEmbeddingBackwardU8F32 => "float32",
			Self::MlRnnScanF32 => "float32",
			Self::MlRnnScanBackwardF32 => "float32",
			Self::MlLayerNormF32 => "float32",
			Self::MlLayerNormBackwardF32 => "float32",
			Self::MlRmsNormF32 => "float32",
			Self::MlRmsNormBackwardF32 => "float32",
			Self::MlGeluF32 => "float32",
			Self::MlGeluBackwardF32 => "float32",
			Self::MlSiluF32 => "float32",
			Self::MlSiluBackwardF32 => "float32",
			Self::MlReluF32 => "float32",
			Self::MlReluBackwardF32 => "float32",
			Self::MlTanhF32 => "float32",
			Self::MlTanhBackwardF32 => "float32",
			Self::MlSigmoidF32 => "float32",
			Self::MlSigmoidBackwardF32 => "float32",
			Self::MlLeakyReluF32 => "float32",
			Self::MlLeakyReluBackwardF32 => "float32",
			Self::MlEluF32 => "float32",
			Self::MlEluBackwardF32 => "float32",
			Self::MlMishF32 => "float32",
			Self::MlMishBackwardF32 => "float32",
			Self::MlSoftplusF32 => "float32",
			Self::MlSoftplusBackwardF32 => "float32",
			Self::MlQkvProjectionBiasF32 => "float32",
			Self::MlSwigluF32 => "float32",
			Self::MlSwigluBackwardF32 => "float32",
			Self::MlGateUpSwigluBiasF32 => "float32",
			Self::MlAdamWMany4F32 => "float32",
			Self::MlAdamWMany4GraphF32 => "float32",
			Self::MlRopeF32 => "float32",
			Self::MlRopeBackwardF32 => "float32",
			Self::MlAvgPool2dF32 => "float32",
			Self::MlAvgPool2dBackwardF32 => "float32",
			Self::MlMaxPool2dF32 => "float32",
			Self::MlMaxPool2dBackwardF32 => "float32",
			Self::MlAdaptiveAvgPool2dF32 => "float32",
			Self::MlAdaptiveAvgPool2dBackwardF32 => "float32",
			Self::MlBatchNorm2dF32 => "float32",
			Self::MlBatchNorm2dWithStatsF32 => "float32",
			Self::MlBatchNorm2dRunningUpdateF32 => "float32",
			Self::MlBatchNorm2dBackwardF32 => "float32",
			Self::MlBatchNorm2dInputBackwardF32 => "float32",
			Self::MlUpsample2dNearestF32 => "float32",
			Self::MlUpsample2dBilinearF32 => "float32",
			Self::MlUpsample2dNearestBackwardF32 => "float32",
			Self::MlUpsample2dBilinearBackwardF32 => "float32",
			Self::MlConv2dF32 => "float32",
			Self::MlConv2dBackwardF32 => "float32",
			Self::MlConv2dParameterBackwardF32 => "float32",
			Self::MlConv1dIm2ColF32 => "float32",
			Self::MlConv1dBiasAddF32 => "float32",
			Self::MlConv1dTransposeF32 => "float32",
			Self::MlConv1dBackwardF32 => "float32",
			Self::MlConv1dParameterBackwardF32 => "float32",
			Self::MlConvTranspose1dF32 => "float32",
			Self::MlConvTranspose1dBackwardF32 => "float32",
			Self::MlConvTranspose2dF32 => "float32",
			Self::MlConvTranspose2dBiasAddF32 => "float32",
			Self::MlConvTranspose2dBackwardF32 => "float32",
			Self::MlConvTranspose2dParameterBackwardF32 => "float32",
			Self::MlGruScanF32 => "float32",
			Self::MlGruScanBackwardF32 => "float32",
			Self::MlGruCellF32 => "float32",
			Self::MlGruCellBackwardF32 => "float32",
			Self::MlRnnCellF32 => "float32",
			Self::MlRnnCellBackwardF32 => "float32",
			Self::MlBmmF32 => "float32",
			Self::MlBmmTiled16F32 => "float32",
			Self::MlBmmNtF32 => "float32",
			Self::MlBmmNtTiled16F32 => "float32",
			Self::MlBmmTnF32 => "float32",
			Self::MlBmmTnTiled16F32 => "float32",
			Self::MlSplitHeadsF32 => "float32",
			Self::MlMergeHeadsF32 => "float32",
			Self::MlSoftmaxScaledMaskedF32 => "float32",
			Self::MlSoftmaxScaledMaskedN32F32 => "float32",
			Self::MlSoftmaxScaledMaskedBackwardF32 => "float32",
			Self::MlSdpaSoftmaxF32 => "float32",
			Self::MlSdpaSoftmaxN32F32 => "float32",
			Self::MlFlashAttentionCausalF32 => "float32",
			Self::MlFlashAttentionCausalBackwardQF32 => "float32",
			Self::MlFlashAttentionCausalBackwardKvF32 => "float32",
			Self::MlMoeRouteWeightsF32 => "float32",
			Self::MlMoeRouteWeightsBackwardF32 => "float32",
			Self::MlMoeGatherF32 => "float32",
			Self::MlMoeGatherBackwardF32 => "float32",
			Self::MlMoeCombineF32 => "float32",
			Self::MlMoeCombineBackwardF32 => "float32",
			Self::MlGroupedLinearMF32 => "float32",
			Self::MlGroupedLinearMDataBackwardF32 => "float32",
			Self::MlGroupedLinearMParameterBackwardF32 => "float32",
			Self::MlSiluMulF32 => "float32",
			Self::MlSiluMulBackwardF32 => "float32",
			Self::MlGroupedGemmMF32 => "float32",
			Self::MlGroupedGemmMDataBackwardF32 => "float32",
			Self::MlGroupedGemmMParameterBackwardF32 => "float32",
			Self::MlFlowLinearMatchF32 => "float32",
			Self::MlFlowEulerStepF32 => "float32",
			Self::MlFlowMaskedMseF32 => "float32",
			Self::MlFlowMaskedMseBackwardF32 => "float32",
			Self::MlGaeF32 => "float32",
			Self::MlRolloutAppendF32 => "float32",
			Self::MlRolloutResetU8 => "uint8",
			Self::MlReplayAppendBatchF32 => "float32",
			Self::MlReplaySampleF32 => "float32",
			Self::MlDqnTargetF32 => "float32",
			Self::MlSacTargetF32 => "float32",
			Self::MlCartPoleResetF32 => "float32",
			Self::MlCartPoleStepF32 => "float32",
			Self::MlLunarLanderResetF32 => "float32",
			Self::MlLunarLanderStepF32 => "float32",
			Self::MlRmsNormGatedF32 => "float32",
			Self::MlRmsNormGatedBackwardF32 => "float32",
			Self::MlMamba3PreprocessF32 => "float32",
			Self::MlMamba3PreprocessBackwardF32 => "float32",
			Self::MlMamba3PreprocessBackwardReduceF32 => "float32",
			Self::MlMamba3SisoF32 => "float32",
			Self::MlMamba3SisoBackwardPrepareF32 => "float32",
			Self::MlMamba3SisoStepF32 => "float32",
			Self::MlMamba3SisoBackwardStateF32 => "float32",
			Self::MlMamba3SisoBackwardReverseP16F32 => "float32",
			Self::MlMamba3SisoBackwardFinalizeF32 => "float32",
			Self::MlMamba3SisoBackwardReduceF32 => "float32",
			Self::MlMamba3SisoBackwardGroupReduceF32 => "float32",
			Self::MlMamba3MimoF32 => "float32",
			Self::MlMamba3MimoBackwardCoreF32 => "float32",
			Self::MlMamba3MimoStepF32 => "float32",
			Self::MlMamba3MimoBackwardPrepareF32 => "float32",
			Self::MlMamba3MimoBackwardPostF32 => "float32",
			Self::MlMamba3MimoBackwardRotateF32 => "float32",
			Self::MlMamba3MimoBackwardReduceF32 => "float32",
			Self::MlMamba3SisoBackwardGenericF32 => "float32",
			Self::MlMamba3SisoBackwardGenericReduceF32 => "float32",
			Self::MlMamba3SisoChunkSummaryF32 => "float32",
			Self::MlMamba3SisoChunkPrefixF32 => "float32",
			Self::MlMamba3SisoChunkDpreF32 => "float32",
			Self::MlMamba3SisoChunkBackwardSummaryF32 => "float32",
			Self::MlMamba3SisoChunkBackwardPrefixF32 => "float32",
			Self::MlMamba3SisoChunkBackwardF32 => "float32",
			Self::MlMamba3SisoChunkFinalizeF32 => "float32",
			Self::MlMamba3SisoChunkReduceF32 => "float32",
			Self::MlVqAssignF32 => "float32",
			Self::MlVqLookupF32 => "float32",
			Self::MlVqEmaUpdateF32 => "float32",
			Self::AudioGainF32 => "float32",
			Self::AudioClipF32 => "float32",
			Self::AudioSaturateF32 => "float32",
			Self::AudioResampleF32 => "float32",
			Self::AudioFadeF32 => "float32",
			Self::AudioMixF32 => "float32",
			Self::AudioAmplitudeToDbF32 => "float32",
			Self::AudioWaveformEnvelopeF32 => "float32",
			Self::AudioPreEmphasisF32 => "float32",
			Self::AudioToMonoF32 => "float32",
			Self::AudioNormalizeLevelF32 => "float32",
			Self::AudioNormalizeApplyF32 => "float32",
			Self::AudioBiquadSummaryF32 => "float32",
			Self::AudioBiquadScanF32 => "float32",
			Self::AudioBiquadApplyF32 => "float32",
			Self::AudioReverbCombF32 => "float32",
			Self::AudioReverbSumF32 => "float32",
			Self::AudioReverbAllpassF32 => "float32",
			Self::AudioReverbMixF32 => "float32",
			Self::AudioStftF32 => "float32",
			Self::AudioMelFilterbankF32 => "float32",
			Self::AudioMelNormalizeF32 => "float32",
			Self::AudioMfccDctF32 => "float32",
			Self::AudioSosFilterF32 => "float32",
			Self::CryptographyShake128U8 => "uint8",
			Self::CryptographyShake256U8 => "uint8",
			Self::CryptographyKeccakF1600U8 => "uint8",
			Self::CryptographyMerkleReduceU8 => "uint8",
			Self::CryptographyMerkleCopyU8 => "uint8",
			Self::CryptographyMlDsa65VerifyU8 => "uint8",
			Self::CryptographyMlDsa44VerifyU8 => "uint8",
			Self::CryptographyMlDsa87VerifyU8 => "uint8",
			Self::CryptographyMlDsa65VerifyPrehashedU8 => "uint8",
			Self::CryptographyMlDsa44VerifyPrehashedU8 => "uint8",
			Self::CryptographyMlDsa87VerifyPrehashedU8 => "uint8",
			Self::CryptographyMlDsa65VerifyHashMessageU8 => "uint8",
			Self::CryptographyMlDsa44VerifyHashMessageU8 => "uint8",
			Self::CryptographyMlDsa87VerifyHashMessageU8 => "uint8",
			Self::CryptographyMlKemKeygenU8 => "uint8",
			Self::CryptographyMlKemEncapsU8 => "uint8",
			Self::CryptographyMlKemDecapsU8 => "uint8",
			Self::CryptographyMlDsaKeygenU8 => "uint8",
			Self::CryptographyMlDsaSignU8 => "uint8",
			Self::CryptographyMlDsaSignMessageU8 => "uint8",
			Self::CryptographyMlDsaSignPrehashedU8 => "uint8",
			Self::CryptographyMlDsaSignHashMessageU8 => "uint8",
			Self::ImageResizeNearestF32 => "float32",
			Self::ImageResizeBilinearF32 => "float32",
			Self::ImageCropF32 => "float32",
			Self::ImageFlipF32 => "float32",
			Self::ImageRotateF32 => "float32",
			Self::ImagePadF32 => "float32",
			Self::ImageCenterCropF32 => "float32",
			Self::ImageRemapF32 => "float32",
			Self::ImageWarpAffineF32 => "float32",
			Self::ImageWarpPerspectiveF32 => "float32",
			Self::ImageThresholdBinaryF32 => "float32",
			Self::ImageThresholdBinaryInvF32 => "float32",
			Self::ImageThresholdTruncateF32 => "float32",
			Self::ImageThresholdToZeroF32 => "float32",
			Self::ImageThresholdToZeroInvF32 => "float32",
			Self::ImageInRangeF32 => "float32",
			Self::ImageClampF32 => "float32",
			Self::ImageInvertF32 => "float32",
			Self::ImageBrightnessContrastF32 => "float32",
			Self::ImageGammaContrastF32 => "float32",
			Self::ImageSolarizeF32 => "float32",
			Self::ImagePosterizeF32 => "float32",
			Self::ImageGrayscaleF32 => "float32",
			Self::ImageAlphaBlendF32 => "float32",
			Self::ImageCompositeF32 => "float32",
			Self::ImageEraseF32 => "float32",
			Self::ImageColorTwistF32 => "float32",
			Self::ImageChannelReorderF32 => "float32",
			Self::ImageGaussianNoiseF32 => "float32",
			Self::ImageSaltPepperNoiseF32 => "float32",
			Self::ImageConvolve2dF32 => "float32",
			Self::ImageSeparableConvolve2dF32 => "float32",
			Self::ImageAverageBlurF32 => "float32",
			Self::ImageSobelF32 => "float32",
			Self::ImageScharrF32 => "float32",
			Self::ImageLaplacianF32 => "float32",
			Self::ImageErodeF32 => "float32",
			Self::ImageDilateF32 => "float32",
			Self::ImageMorphologyOpenF32 => "float32",
			Self::ImageMorphologyCloseF32 => "float32",
			Self::ImageMorphologyGradientF32 => "float32",
			Self::ImageGaussianBlurF32 => "float32",
			Self::ImageSharpenF32 => "float32",
			Self::ImageMedianBlurF32 => "float32",
			Self::ImageBilateralFilterF32 => "float32",
			Self::ImageUnsharpMaskF32 => "float32",
			Self::ImageMorphologyTopHatF32 => "float32",
			Self::ImageMorphologyBlackHatF32 => "float32",
			Self::ImageAdaptiveThresholdMeanF32 => "float32",
			Self::ImageAdaptiveThresholdGaussianF32 => "float32",
			Self::ImageNormalizeF32 => "float32",
			Self::ImageConvertColorF32 => "float32",
			Self::ImageResizeNormalizeF32 => "float32",
			Self::ImageSegmentationOverlayF32 => "float32",
			Self::VisionBoxIouF32 => "float32",
			Self::VisionNmsF32 => "float32",
			Self::VisionConfusionMatrixI32 => "int32",
			Self::VisionBinaryMaskCountsU8 => "uint8",
			Self::VisionDetectionMetricCurvesF32 => "float32",
			Self::VisionDetectionAveragePrecisionF32 => "float32",
			Self::VisionDetectionMeanAveragePrecisionF32 => "float32",
			Self::VisionSegmentationConfusionI32 => "int32",
			Self::VisionSegmentationMetricsF32 => "float32",
			Self::VisionConfusionMatrixClearU32 => "uint32",
			Self::VisionBinaryMaskCountsClearU32 => "uint32",
			Self::VisionSegmentationConfusionClearU32 => "uint32",
		}
	}

	pub(crate) const fn training_replay_role(self) -> TrainingReplayRole {
		match self {
			Self::MatrixAddF32 => TrainingReplayRole::Safe,
			Self::MatrixAddI32 => TrainingReplayRole::Safe,
			Self::MatrixAddBroadcastF32 => TrainingReplayRole::Safe,
			Self::MatrixAddBroadcastI32 => TrainingReplayRole::Safe,
			Self::MatrixSubF32 => TrainingReplayRole::Safe,
			Self::MatrixSubBroadcastF32 => TrainingReplayRole::Safe,
			Self::MatrixMulF32 => TrainingReplayRole::Safe,
			Self::MatrixMulBroadcastF32 => TrainingReplayRole::Safe,
			Self::MatrixDivF32 => TrainingReplayRole::Safe,
			Self::MatrixDivBroadcastF32 => TrainingReplayRole::Safe,
			Self::MatrixScaleF32 => TrainingReplayRole::Safe,
			Self::MatrixNegF32 => TrainingReplayRole::Safe,
			Self::MatrixAbsF32 => TrainingReplayRole::Safe,
			Self::MatrixLogF32 => TrainingReplayRole::Safe,
			Self::MatrixSqrtF32 => TrainingReplayRole::Safe,
			Self::MatrixPowF32 => TrainingReplayRole::Safe,
			Self::MatrixAddScalarF32 => TrainingReplayRole::Safe,
			Self::MatrixSubScalarF32 => TrainingReplayRole::Safe,
			Self::MatrixDivScalarF32 => TrainingReplayRole::Safe,
			Self::MatrixExpF32 => TrainingReplayRole::Safe,
			Self::MatrixSinF32 => TrainingReplayRole::Safe,
			Self::MatrixCosF32 => TrainingReplayRole::Safe,
			Self::MatrixReciprocalF32 => TrainingReplayRole::Safe,
			Self::MatrixClampMaxF32 => TrainingReplayRole::Safe,
			Self::MatrixClampMinF32 => TrainingReplayRole::Safe,
			Self::MatrixCopyF32 => TrainingReplayRole::Safe,
			Self::MatrixCopyU8 => TrainingReplayRole::Safe,
			Self::MatrixCopyI32 => TrainingReplayRole::Safe,
			Self::MatrixCopyU32 => TrainingReplayRole::Safe,
			Self::MatrixMatMulNtTiledF32 => TrainingReplayRole::Safe,
			Self::MatrixSoftmaxF32 => TrainingReplayRole::Safe,
			Self::MatrixSoftmaxBackwardF32 => TrainingReplayRole::Safe,
			Self::MatrixLogSoftmaxF32 => TrainingReplayRole::Safe,
			Self::MatrixLogSoftmaxBackwardF32 => TrainingReplayRole::Safe,
			Self::MatrixSumF32 => TrainingReplayRole::Safe,
			Self::MatrixSumAxisF32 => TrainingReplayRole::Safe,
			Self::MatrixSumBackwardF32 => TrainingReplayRole::Safe,
			Self::MatrixCategoricalAccuracyCountF32 => TrainingReplayRole::Safe,
			Self::MatrixMaskedCategoricalAccuracyCountF32 => TrainingReplayRole::Safe,
			Self::MatrixPhiloxUniformF32 => TrainingReplayRole::FrozenRng,
			Self::MatrixPhiloxNormalF32 => TrainingReplayRole::FrozenRng,
			Self::MatrixPhiloxUniformReplayF32 => TrainingReplayRole::ReplayRng,
			Self::MatrixPhiloxNormalReplayF32 => TrainingReplayRole::ReplayRng,
			Self::MatrixPhiloxReplayAdvanceU32 => TrainingReplayRole::RngStateAdvance,
			Self::MatrixDropoutF32 => TrainingReplayRole::FrozenRng,
			Self::MatrixDropoutBackwardF32 => TrainingReplayRole::FrozenRng,
			Self::MatrixSampleLogitsGreedyF32 => TrainingReplayRole::Safe,
			Self::MatrixSampleLogitsDenseF32 => TrainingReplayRole::Safe,
			Self::MatrixSampleLogitsSortedF32 => TrainingReplayRole::Safe,
			Self::MatrixDropoutReplayF32 => TrainingReplayRole::ReplayRng,
			Self::MatrixDropoutBackwardReplayF32 => TrainingReplayRole::ReplayRng,
			Self::MatrixTopKF32 => TrainingReplayRole::Safe,
			Self::MatrixTopKMaskF32 => TrainingReplayRole::Safe,
			Self::MatrixMoeExpertPlanU32 => TrainingReplayRole::Safe,
			Self::MatrixMoeRoutingBiasUpdateF32 => TrainingReplayRole::Safe,
			Self::MatrixSliceF32 => TrainingReplayRole::Safe,
			Self::MatrixSliceBackwardF32 => TrainingReplayRole::Safe,
			Self::MatrixRepeatInterleaveF32 => TrainingReplayRole::Safe,
			Self::MatrixRepeatInterleaveBackwardF32 => TrainingReplayRole::Safe,
			Self::MatrixGatherF32 => TrainingReplayRole::Safe,
			Self::MatrixGatherBackwardF32 => TrainingReplayRole::Safe,
			Self::MatrixGatherLastDimF32 => TrainingReplayRole::Safe,
			Self::MatrixGatherLastDimBackwardF32 => TrainingReplayRole::Safe,
			Self::MatrixConcatF32 => TrainingReplayRole::Safe,
			Self::MatrixTransposeF32 => TrainingReplayRole::Safe,
			Self::MatrixEqualF32 => TrainingReplayRole::Safe,
			Self::MlPpoClippedPolicyF32 => TrainingReplayRole::Safe,
			Self::MlPpoClippedPolicyBackwardF32 => TrainingReplayRole::Safe,
			Self::MlLinearF32 => TrainingReplayRole::Safe,
			Self::MlLinearBackwardF32 => TrainingReplayRole::Safe,
			Self::MlLinearParameterBackwardF32 => TrainingReplayRole::Safe,
			Self::MlCrossEntropyF32 => TrainingReplayRole::Safe,
			Self::MlCrossEntropySumF32 => TrainingReplayRole::Safe,
			Self::MlCrossEntropyBackwardF32 => TrainingReplayRole::Safe,
			Self::MlMaskedCrossEntropyF32 => TrainingReplayRole::Safe,
			Self::MlMaskedCrossEntropyBackwardF32 => TrainingReplayRole::Safe,
			Self::MlSmoothL1F32 => TrainingReplayRole::Safe,
			Self::MlSmoothL1BackwardF32 => TrainingReplayRole::Safe,
			Self::MlSmoothL1MeanF32 => TrainingReplayRole::Safe,
			Self::MlMseF32 => TrainingReplayRole::Safe,
			Self::MlMseBackwardF32 => TrainingReplayRole::Safe,
			Self::MlL1F32 => TrainingReplayRole::Safe,
			Self::MlL1BackwardF32 => TrainingReplayRole::Safe,
			Self::MlBceF32 => TrainingReplayRole::Safe,
			Self::MlBceBackwardF32 => TrainingReplayRole::Safe,
			Self::MlSgdF32 => TrainingReplayRole::HostSteppedOptimizer,
			Self::MlClipGradNormReduceF32 => TrainingReplayRole::Safe,
			Self::MlClipGradNormScaleF32 => TrainingReplayRole::Safe,
			Self::MlSgdMomentumF32 => TrainingReplayRole::HostSteppedOptimizer,
			Self::MlAdamF32 => TrainingReplayRole::HostSteppedOptimizer,
			Self::MlMuonNesterovF32 => TrainingReplayRole::HostSteppedOptimizer,
			Self::MlMuonVectorF32 => TrainingReplayRole::HostSteppedOptimizer,
			Self::MlMuonNormalizeF32 => TrainingReplayRole::HostSteppedOptimizer,
			Self::MlMuonMatMulAxpbyF32 => TrainingReplayRole::HostSteppedOptimizer,
			Self::MlMuonLinearCombinationF32 => TrainingReplayRole::HostSteppedOptimizer,
			Self::MlMuonTransposeF32 => TrainingReplayRole::HostSteppedOptimizer,
			Self::MlMuonApplyF32 => TrainingReplayRole::HostSteppedOptimizer,
			Self::MlAdamWF32 => TrainingReplayRole::HostSteppedOptimizer,
			Self::MlAdamWGraphAdvanceU32 => TrainingReplayRole::OptimizerStateAdvance,
			Self::MlAdamWGraphF32 => TrainingReplayRole::OptimizerStateUpdate,
			Self::MlEmbeddingF32 => TrainingReplayRole::Safe,
			Self::MlEmbeddingBackwardF32 => TrainingReplayRole::Safe,
			Self::MlChannelNormF32 => TrainingReplayRole::Safe,
			Self::MlChannelNormBackwardF32 => TrainingReplayRole::Safe,
			Self::MlChannelNormReluF32 => TrainingReplayRole::Safe,
			Self::MlChannelNormReluBackwardF32 => TrainingReplayRole::Safe,
			Self::MlEmbeddingU8F32 => TrainingReplayRole::Safe,
			Self::MlEmbeddingBackwardU8F32 => TrainingReplayRole::Safe,
			Self::MlRnnScanF32 => TrainingReplayRole::Safe,
			Self::MlRnnScanBackwardF32 => TrainingReplayRole::Safe,
			Self::MlLayerNormF32 => TrainingReplayRole::Safe,
			Self::MlLayerNormBackwardF32 => TrainingReplayRole::Safe,
			Self::MlRmsNormF32 => TrainingReplayRole::Safe,
			Self::MlRmsNormBackwardF32 => TrainingReplayRole::Safe,
			Self::MlGeluF32 => TrainingReplayRole::Safe,
			Self::MlGeluBackwardF32 => TrainingReplayRole::Safe,
			Self::MlSiluF32 => TrainingReplayRole::Safe,
			Self::MlSiluBackwardF32 => TrainingReplayRole::Safe,
			Self::MlReluF32 => TrainingReplayRole::Safe,
			Self::MlReluBackwardF32 => TrainingReplayRole::Safe,
			Self::MlTanhF32 => TrainingReplayRole::Safe,
			Self::MlTanhBackwardF32 => TrainingReplayRole::Safe,
			Self::MlSigmoidF32 => TrainingReplayRole::Safe,
			Self::MlSigmoidBackwardF32 => TrainingReplayRole::Safe,
			Self::MlLeakyReluF32 => TrainingReplayRole::Safe,
			Self::MlLeakyReluBackwardF32 => TrainingReplayRole::Safe,
			Self::MlEluF32 => TrainingReplayRole::Safe,
			Self::MlEluBackwardF32 => TrainingReplayRole::Safe,
			Self::MlMishF32 => TrainingReplayRole::Safe,
			Self::MlMishBackwardF32 => TrainingReplayRole::Safe,
			Self::MlSoftplusF32 => TrainingReplayRole::Safe,
			Self::MlSoftplusBackwardF32 => TrainingReplayRole::Safe,
			Self::MlQkvProjectionBiasF32 => TrainingReplayRole::Safe,
			Self::MlSwigluF32 => TrainingReplayRole::Safe,
			Self::MlSwigluBackwardF32 => TrainingReplayRole::Safe,
			Self::MlGateUpSwigluBiasF32 => TrainingReplayRole::Safe,
			Self::MlAdamWMany4F32 => TrainingReplayRole::HostSteppedOptimizer,
			Self::MlAdamWMany4GraphF32 => TrainingReplayRole::OptimizerStateUpdate,
			Self::MlRopeF32 => TrainingReplayRole::Safe,
			Self::MlRopeBackwardF32 => TrainingReplayRole::Safe,
			Self::MlAvgPool2dF32 => TrainingReplayRole::Safe,
			Self::MlAvgPool2dBackwardF32 => TrainingReplayRole::Safe,
			Self::MlMaxPool2dF32 => TrainingReplayRole::Safe,
			Self::MlMaxPool2dBackwardF32 => TrainingReplayRole::Safe,
			Self::MlAdaptiveAvgPool2dF32 => TrainingReplayRole::Safe,
			Self::MlAdaptiveAvgPool2dBackwardF32 => TrainingReplayRole::Safe,
			Self::MlBatchNorm2dF32 => TrainingReplayRole::Safe,
			Self::MlBatchNorm2dWithStatsF32 => TrainingReplayRole::Safe,
			Self::MlBatchNorm2dRunningUpdateF32 => TrainingReplayRole::Safe,
			Self::MlBatchNorm2dBackwardF32 => TrainingReplayRole::Safe,
			Self::MlBatchNorm2dInputBackwardF32 => TrainingReplayRole::Safe,
			Self::MlUpsample2dNearestF32 => TrainingReplayRole::Safe,
			Self::MlUpsample2dBilinearF32 => TrainingReplayRole::Safe,
			Self::MlUpsample2dNearestBackwardF32 => TrainingReplayRole::Safe,
			Self::MlUpsample2dBilinearBackwardF32 => TrainingReplayRole::Safe,
			Self::MlConv2dF32 => TrainingReplayRole::Safe,
			Self::MlConv2dBackwardF32 => TrainingReplayRole::Safe,
			Self::MlConv2dParameterBackwardF32 => TrainingReplayRole::Safe,
			Self::MlConv1dIm2ColF32 => TrainingReplayRole::Safe,
			Self::MlConv1dBiasAddF32 => TrainingReplayRole::Safe,
			Self::MlConv1dTransposeF32 => TrainingReplayRole::Safe,
			Self::MlConv1dBackwardF32 => TrainingReplayRole::Safe,
			Self::MlConv1dParameterBackwardF32 => TrainingReplayRole::Safe,
			Self::MlConvTranspose1dF32 => TrainingReplayRole::Safe,
			Self::MlConvTranspose1dBackwardF32 => TrainingReplayRole::Safe,
			Self::MlConvTranspose2dF32 => TrainingReplayRole::Safe,
			Self::MlConvTranspose2dBiasAddF32 => TrainingReplayRole::Safe,
			Self::MlConvTranspose2dBackwardF32 => TrainingReplayRole::Safe,
			Self::MlConvTranspose2dParameterBackwardF32 => TrainingReplayRole::Safe,
			Self::MlGruScanF32 => TrainingReplayRole::Safe,
			Self::MlGruScanBackwardF32 => TrainingReplayRole::Safe,
			Self::MlGruCellF32 => TrainingReplayRole::Safe,
			Self::MlGruCellBackwardF32 => TrainingReplayRole::Safe,
			Self::MlRnnCellF32 => TrainingReplayRole::Safe,
			Self::MlRnnCellBackwardF32 => TrainingReplayRole::Safe,
			Self::MlBmmF32 => TrainingReplayRole::Safe,
			Self::MlBmmTiled16F32 => TrainingReplayRole::Safe,
			Self::MlBmmNtF32 => TrainingReplayRole::Safe,
			Self::MlBmmNtTiled16F32 => TrainingReplayRole::Safe,
			Self::MlBmmTnF32 => TrainingReplayRole::Safe,
			Self::MlBmmTnTiled16F32 => TrainingReplayRole::Safe,
			Self::MlSplitHeadsF32 => TrainingReplayRole::Safe,
			Self::MlMergeHeadsF32 => TrainingReplayRole::Safe,
			Self::MlSoftmaxScaledMaskedF32 => TrainingReplayRole::Safe,
			Self::MlSoftmaxScaledMaskedN32F32 => TrainingReplayRole::Safe,
			Self::MlSoftmaxScaledMaskedBackwardF32 => TrainingReplayRole::Safe,
			Self::MlSdpaSoftmaxF32 => TrainingReplayRole::Safe,
			Self::MlSdpaSoftmaxN32F32 => TrainingReplayRole::Safe,
			Self::MlFlashAttentionCausalF32 => TrainingReplayRole::Safe,
			Self::MlFlashAttentionCausalBackwardQF32 => TrainingReplayRole::Safe,
			Self::MlFlashAttentionCausalBackwardKvF32 => TrainingReplayRole::Safe,
			Self::MlMoeRouteWeightsF32 => TrainingReplayRole::Safe,
			Self::MlMoeRouteWeightsBackwardF32 => TrainingReplayRole::Safe,
			Self::MlMoeGatherF32 => TrainingReplayRole::Safe,
			Self::MlMoeGatherBackwardF32 => TrainingReplayRole::Safe,
			Self::MlMoeCombineF32 => TrainingReplayRole::Safe,
			Self::MlMoeCombineBackwardF32 => TrainingReplayRole::Safe,
			Self::MlGroupedLinearMF32 => TrainingReplayRole::Safe,
			Self::MlGroupedLinearMDataBackwardF32 => TrainingReplayRole::Safe,
			Self::MlGroupedLinearMParameterBackwardF32 => TrainingReplayRole::Safe,
			Self::MlSiluMulF32 => TrainingReplayRole::Safe,
			Self::MlSiluMulBackwardF32 => TrainingReplayRole::Safe,
			Self::MlGroupedGemmMF32 => TrainingReplayRole::Safe,
			Self::MlGroupedGemmMDataBackwardF32 => TrainingReplayRole::Safe,
			Self::MlGroupedGemmMParameterBackwardF32 => TrainingReplayRole::Safe,
			Self::MlFlowLinearMatchF32 => TrainingReplayRole::Safe,
			Self::MlFlowEulerStepF32 => TrainingReplayRole::Safe,
			Self::MlFlowMaskedMseF32 => TrainingReplayRole::Safe,
			Self::MlFlowMaskedMseBackwardF32 => TrainingReplayRole::Safe,
			Self::MlGaeF32 => TrainingReplayRole::Safe,
			Self::MlRolloutAppendF32 => TrainingReplayRole::Safe,
			Self::MlRolloutResetU8 => TrainingReplayRole::Safe,
			Self::MlReplayAppendBatchF32 => TrainingReplayRole::Safe,
			Self::MlReplaySampleF32 => TrainingReplayRole::Safe,
			Self::MlDqnTargetF32 => TrainingReplayRole::Safe,
			Self::MlSacTargetF32 => TrainingReplayRole::Safe,
			Self::MlCartPoleResetF32 => TrainingReplayRole::Safe,
			Self::MlCartPoleStepF32 => TrainingReplayRole::Safe,
			Self::MlLunarLanderResetF32 => TrainingReplayRole::Safe,
			Self::MlLunarLanderStepF32 => TrainingReplayRole::Safe,
			Self::MlRmsNormGatedF32 => TrainingReplayRole::Safe,
			Self::MlRmsNormGatedBackwardF32 => TrainingReplayRole::Safe,
			Self::MlMamba3PreprocessF32 => TrainingReplayRole::Safe,
			Self::MlMamba3PreprocessBackwardF32 => TrainingReplayRole::Safe,
			Self::MlMamba3PreprocessBackwardReduceF32 => TrainingReplayRole::Safe,
			Self::MlMamba3SisoF32 => TrainingReplayRole::Safe,
			Self::MlMamba3SisoBackwardPrepareF32 => TrainingReplayRole::Safe,
			Self::MlMamba3SisoStepF32 => TrainingReplayRole::Safe,
			Self::MlMamba3SisoBackwardStateF32 => TrainingReplayRole::Safe,
			Self::MlMamba3SisoBackwardReverseP16F32 => TrainingReplayRole::Safe,
			Self::MlMamba3SisoBackwardFinalizeF32 => TrainingReplayRole::Safe,
			Self::MlMamba3SisoBackwardReduceF32 => TrainingReplayRole::Safe,
			Self::MlMamba3SisoBackwardGroupReduceF32 => TrainingReplayRole::Safe,
			Self::MlMamba3MimoF32 => TrainingReplayRole::Safe,
			Self::MlMamba3MimoBackwardCoreF32 => TrainingReplayRole::Safe,
			Self::MlMamba3MimoStepF32 => TrainingReplayRole::Safe,
			Self::MlMamba3MimoBackwardPrepareF32 => TrainingReplayRole::Safe,
			Self::MlMamba3MimoBackwardPostF32 => TrainingReplayRole::Safe,
			Self::MlMamba3MimoBackwardRotateF32 => TrainingReplayRole::Safe,
			Self::MlMamba3MimoBackwardReduceF32 => TrainingReplayRole::Safe,
			Self::MlMamba3SisoBackwardGenericF32 => TrainingReplayRole::Safe,
			Self::MlMamba3SisoBackwardGenericReduceF32 => TrainingReplayRole::Safe,
			Self::MlMamba3SisoChunkSummaryF32 => TrainingReplayRole::Safe,
			Self::MlMamba3SisoChunkPrefixF32 => TrainingReplayRole::Safe,
			Self::MlMamba3SisoChunkDpreF32 => TrainingReplayRole::Safe,
			Self::MlMamba3SisoChunkBackwardSummaryF32 => TrainingReplayRole::Safe,
			Self::MlMamba3SisoChunkBackwardPrefixF32 => TrainingReplayRole::Safe,
			Self::MlMamba3SisoChunkBackwardF32 => TrainingReplayRole::Safe,
			Self::MlMamba3SisoChunkFinalizeF32 => TrainingReplayRole::Safe,
			Self::MlMamba3SisoChunkReduceF32 => TrainingReplayRole::Safe,
			Self::MlVqAssignF32 => TrainingReplayRole::Safe,
			Self::MlVqLookupF32 => TrainingReplayRole::Safe,
			Self::MlVqEmaUpdateF32 => TrainingReplayRole::Safe,
			Self::AudioGainF32 => TrainingReplayRole::Safe,
			Self::AudioClipF32 => TrainingReplayRole::Safe,
			Self::AudioSaturateF32 => TrainingReplayRole::Safe,
			Self::AudioResampleF32 => TrainingReplayRole::Safe,
			Self::AudioFadeF32 => TrainingReplayRole::Safe,
			Self::AudioMixF32 => TrainingReplayRole::Safe,
			Self::AudioAmplitudeToDbF32 => TrainingReplayRole::Safe,
			Self::AudioWaveformEnvelopeF32 => TrainingReplayRole::Safe,
			Self::AudioPreEmphasisF32 => TrainingReplayRole::Safe,
			Self::AudioToMonoF32 => TrainingReplayRole::Safe,
			Self::AudioNormalizeLevelF32 => TrainingReplayRole::Safe,
			Self::AudioNormalizeApplyF32 => TrainingReplayRole::Safe,
			Self::AudioBiquadSummaryF32 => TrainingReplayRole::Safe,
			Self::AudioBiquadScanF32 => TrainingReplayRole::Safe,
			Self::AudioBiquadApplyF32 => TrainingReplayRole::Safe,
			Self::AudioReverbCombF32 => TrainingReplayRole::Safe,
			Self::AudioReverbSumF32 => TrainingReplayRole::Safe,
			Self::AudioReverbAllpassF32 => TrainingReplayRole::Safe,
			Self::AudioReverbMixF32 => TrainingReplayRole::Safe,
			Self::AudioStftF32 => TrainingReplayRole::Safe,
			Self::AudioMelFilterbankF32 => TrainingReplayRole::Safe,
			Self::AudioMelNormalizeF32 => TrainingReplayRole::Safe,
			Self::AudioMfccDctF32 => TrainingReplayRole::Safe,
			Self::AudioSosFilterF32 => TrainingReplayRole::Safe,
			Self::CryptographyShake128U8 => TrainingReplayRole::Safe,
			Self::CryptographyShake256U8 => TrainingReplayRole::Safe,
			Self::CryptographyKeccakF1600U8 => TrainingReplayRole::Safe,
			Self::CryptographyMerkleReduceU8 => TrainingReplayRole::Safe,
			Self::CryptographyMerkleCopyU8 => TrainingReplayRole::Safe,
			Self::CryptographyMlDsa65VerifyU8 => TrainingReplayRole::Safe,
			Self::CryptographyMlDsa44VerifyU8 => TrainingReplayRole::Safe,
			Self::CryptographyMlDsa87VerifyU8 => TrainingReplayRole::Safe,
			Self::CryptographyMlDsa65VerifyPrehashedU8 => TrainingReplayRole::Safe,
			Self::CryptographyMlDsa44VerifyPrehashedU8 => TrainingReplayRole::Safe,
			Self::CryptographyMlDsa87VerifyPrehashedU8 => TrainingReplayRole::Safe,
			Self::CryptographyMlDsa65VerifyHashMessageU8 => TrainingReplayRole::Safe,
			Self::CryptographyMlDsa44VerifyHashMessageU8 => TrainingReplayRole::Safe,
			Self::CryptographyMlDsa87VerifyHashMessageU8 => TrainingReplayRole::Safe,
			Self::CryptographyMlKemKeygenU8 => TrainingReplayRole::Safe,
			Self::CryptographyMlKemEncapsU8 => TrainingReplayRole::Safe,
			Self::CryptographyMlKemDecapsU8 => TrainingReplayRole::Safe,
			Self::CryptographyMlDsaKeygenU8 => TrainingReplayRole::Safe,
			Self::CryptographyMlDsaSignU8 => TrainingReplayRole::Safe,
			Self::CryptographyMlDsaSignMessageU8 => TrainingReplayRole::Safe,
			Self::CryptographyMlDsaSignPrehashedU8 => TrainingReplayRole::Safe,
			Self::CryptographyMlDsaSignHashMessageU8 => TrainingReplayRole::Safe,
			Self::ImageResizeNearestF32 => TrainingReplayRole::Safe,
			Self::ImageResizeBilinearF32 => TrainingReplayRole::Safe,
			Self::ImageCropF32 => TrainingReplayRole::Safe,
			Self::ImageFlipF32 => TrainingReplayRole::Safe,
			Self::ImageRotateF32 => TrainingReplayRole::Safe,
			Self::ImagePadF32 => TrainingReplayRole::Safe,
			Self::ImageCenterCropF32 => TrainingReplayRole::Safe,
			Self::ImageRemapF32 => TrainingReplayRole::Safe,
			Self::ImageWarpAffineF32 => TrainingReplayRole::Safe,
			Self::ImageWarpPerspectiveF32 => TrainingReplayRole::Safe,
			Self::ImageThresholdBinaryF32 => TrainingReplayRole::Safe,
			Self::ImageThresholdBinaryInvF32 => TrainingReplayRole::Safe,
			Self::ImageThresholdTruncateF32 => TrainingReplayRole::Safe,
			Self::ImageThresholdToZeroF32 => TrainingReplayRole::Safe,
			Self::ImageThresholdToZeroInvF32 => TrainingReplayRole::Safe,
			Self::ImageInRangeF32 => TrainingReplayRole::Safe,
			Self::ImageClampF32 => TrainingReplayRole::Safe,
			Self::ImageInvertF32 => TrainingReplayRole::Safe,
			Self::ImageBrightnessContrastF32 => TrainingReplayRole::Safe,
			Self::ImageGammaContrastF32 => TrainingReplayRole::Safe,
			Self::ImageSolarizeF32 => TrainingReplayRole::Safe,
			Self::ImagePosterizeF32 => TrainingReplayRole::Safe,
			Self::ImageGrayscaleF32 => TrainingReplayRole::Safe,
			Self::ImageAlphaBlendF32 => TrainingReplayRole::Safe,
			Self::ImageCompositeF32 => TrainingReplayRole::Safe,
			Self::ImageEraseF32 => TrainingReplayRole::Safe,
			Self::ImageColorTwistF32 => TrainingReplayRole::Safe,
			Self::ImageChannelReorderF32 => TrainingReplayRole::Safe,
			Self::ImageGaussianNoiseF32 => TrainingReplayRole::Safe,
			Self::ImageSaltPepperNoiseF32 => TrainingReplayRole::Safe,
			Self::ImageConvolve2dF32 => TrainingReplayRole::Safe,
			Self::ImageSeparableConvolve2dF32 => TrainingReplayRole::Safe,
			Self::ImageAverageBlurF32 => TrainingReplayRole::Safe,
			Self::ImageSobelF32 => TrainingReplayRole::Safe,
			Self::ImageScharrF32 => TrainingReplayRole::Safe,
			Self::ImageLaplacianF32 => TrainingReplayRole::Safe,
			Self::ImageErodeF32 => TrainingReplayRole::Safe,
			Self::ImageDilateF32 => TrainingReplayRole::Safe,
			Self::ImageMorphologyOpenF32 => TrainingReplayRole::Safe,
			Self::ImageMorphologyCloseF32 => TrainingReplayRole::Safe,
			Self::ImageMorphologyGradientF32 => TrainingReplayRole::Safe,
			Self::ImageGaussianBlurF32 => TrainingReplayRole::Safe,
			Self::ImageSharpenF32 => TrainingReplayRole::Safe,
			Self::ImageMedianBlurF32 => TrainingReplayRole::Safe,
			Self::ImageBilateralFilterF32 => TrainingReplayRole::Safe,
			Self::ImageUnsharpMaskF32 => TrainingReplayRole::Safe,
			Self::ImageMorphologyTopHatF32 => TrainingReplayRole::Safe,
			Self::ImageMorphologyBlackHatF32 => TrainingReplayRole::Safe,
			Self::ImageAdaptiveThresholdMeanF32 => TrainingReplayRole::Safe,
			Self::ImageAdaptiveThresholdGaussianF32 => TrainingReplayRole::Safe,
			Self::ImageNormalizeF32 => TrainingReplayRole::Safe,
			Self::ImageConvertColorF32 => TrainingReplayRole::Safe,
			Self::ImageResizeNormalizeF32 => TrainingReplayRole::Safe,
			Self::ImageSegmentationOverlayF32 => TrainingReplayRole::Safe,
			Self::VisionBoxIouF32 => TrainingReplayRole::Safe,
			Self::VisionNmsF32 => TrainingReplayRole::Safe,
			Self::VisionConfusionMatrixI32 => TrainingReplayRole::Safe,
			Self::VisionBinaryMaskCountsU8 => TrainingReplayRole::Safe,
			Self::VisionDetectionMetricCurvesF32 => TrainingReplayRole::Safe,
			Self::VisionDetectionAveragePrecisionF32 => TrainingReplayRole::Safe,
			Self::VisionDetectionMeanAveragePrecisionF32 => TrainingReplayRole::Safe,
			Self::VisionSegmentationConfusionI32 => TrainingReplayRole::Safe,
			Self::VisionSegmentationMetricsF32 => TrainingReplayRole::Safe,
			Self::VisionConfusionMatrixClearU32 => TrainingReplayRole::Safe,
			Self::VisionBinaryMaskCountsClearU32 => TrainingReplayRole::Safe,
			Self::VisionSegmentationConfusionClearU32 => TrainingReplayRole::Safe,
		}
	}

	pub(crate) fn linear_workgroups(self, element_count: u32) -> [u32; 3] {
		let width = self.artifact().dispatch_tile_size[0];
		[element_count.div_ceil(width), 1, 1]
	}

	pub(crate) fn output_workgroups(self, rows: u32, columns: u32) -> [u32; 3] {
		let tile = self.artifact().dispatch_tile_size;
		[rows.div_ceil(tile[0]), columns.div_ceil(tile[1]), 1]
	}
}