Skip to content

Instantly share code, notes, and snippets.

@virtuallyunknown

virtuallyunknown/gist:61c112c53aacb7023704f606e542e697

Created January 12, 2026 19:19
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save virtuallyunknown/61c112c53aacb7023704f606e542e697 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save virtuallyunknown/61c112c53aacb7023704f606e542e697 to your computer and use it in GitHub Desktop.
Download ZIP
zlaunch logs
Raw
gistfile1.txt
This file has been truncated, but you can view the full file.
INFO Starting zlaunch daemon version="0.2.0"
DEBUG Config file not found at "/home/decho/.config/zlaunch/config.toml", using defaults
INFO IPC server listening on "/run/user/1000/zlaunch.sock"
INFO Initialized clipboard history
INFO Detected Niri compositor
INFO Starting clipboard monitor
DEBUG Bound to wlr-data-control-manager
DEBUG Bound to wl_seat
DEBUG Created data control device
DEBUG Clipboard selection changed
DEBUG Adding text to clipboard history: 9 chars
INFO Clipboard monitor initialized successfully
INFO Loaded applications count=44
DEBUG Locale: en-US
DEBUG Parsed 2471 font faces in 54ms.
INFO Presentation support: "VK_KHR_wayland_surface"
INFO Presentation support: "VK_KHR_xcb_surface"
INFO Presentation support: "VK_KHR_xlib_surface"
INFO Presentation support: "VK_EXT_swapchain_colorspace"
INFO Enabling Vulkan Portability
INFO Adapter: "NVIDIA GeForce RTX 4060"
INFO Ray tracing is supported
DEBUG Ray tracing properties: PhysicalDeviceAccelerationStructurePropertiesKHR {
s_type: PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR,
p_next: 0x00007ffe469adf10,
max_geometry_count: 16777215,
max_instance_count: 16777215,
max_primitive_count: 536870911,
max_per_stage_descriptor_acceleration_structures: 1048576,
max_per_stage_descriptor_update_after_bind_acceleration_structures: 1048576,
max_descriptor_set_acceleration_structures: 1048576,
max_descriptor_set_update_after_bind_acceleration_structures: 1048576,
min_acceleration_structure_scratch_offset_alignment: 128,
_marker: PhantomData<&()>,
}
DEBUG Adapter AdapterCapabilities {
api_version: 4211013,
properties: PhysicalDeviceProperties {
api_version: 4211013,
driver_version: 2475425856,
vendor_id: 4318,
device_id: 10370,
device_type: DISCRETE_GPU,
device_name: Ok(
"NVIDIA GeForce RTX 4060",
),
pipeline_cache_uuid: [
29,
251,
217,
119,
119,
107,
69,
24,
65,
171,
161,
149,
199,
104,
113,
40,
],
limits: PhysicalDeviceLimits {
max_image_dimension1_d: 32768,
max_image_dimension2_d: 32768,
max_image_dimension3_d: 16384,
max_image_dimension_cube: 32768,
max_image_array_layers: 2048,
max_texel_buffer_elements: 134217728,
max_uniform_buffer_range: 65536,
max_storage_buffer_range: 4294967295,
max_push_constants_size: 256,
max_memory_allocation_count: 4294967295,
max_sampler_allocation_count: 4000,
buffer_image_granularity: 1024,
sparse_address_space_size: 1099511627776,
max_bound_descriptor_sets: 32,
max_per_stage_descriptor_samplers: 1048576,
max_per_stage_descriptor_uniform_buffers: 1048576,
max_per_stage_descriptor_storage_buffers: 1048576,
max_per_stage_descriptor_sampled_images: 1048576,
max_per_stage_descriptor_storage_images: 1048576,
max_per_stage_descriptor_input_attachments: 1048576,
max_per_stage_resources: 4294967295,
max_descriptor_set_samplers: 1048576,
max_descriptor_set_uniform_buffers: 1048576,
max_descriptor_set_uniform_buffers_dynamic: 15,
max_descriptor_set_storage_buffers: 1048576,
max_descriptor_set_storage_buffers_dynamic: 16,
max_descriptor_set_sampled_images: 1048576,
max_descriptor_set_storage_images: 1048576,
max_descriptor_set_input_attachments: 1048576,
max_vertex_input_attributes: 32,
max_vertex_input_bindings: 32,
max_vertex_input_attribute_offset: 2047,
max_vertex_input_binding_stride: 2048,
max_vertex_output_components: 128,
max_tessellation_generation_level: 64,
max_tessellation_patch_size: 32,
max_tessellation_control_per_vertex_input_components: 128,
max_tessellation_control_per_vertex_output_components: 128,
max_tessellation_control_per_patch_output_components: 120,
max_tessellation_control_total_output_components: 4216,
max_tessellation_evaluation_input_components: 128,
max_tessellation_evaluation_output_components: 128,
max_geometry_shader_invocations: 32,
max_geometry_input_components: 128,
max_geometry_output_components: 128,
max_geometry_output_vertices: 1024,
max_geometry_total_output_components: 1024,
max_fragment_input_components: 128,
max_fragment_output_attachments: 8,
max_fragment_dual_src_attachments: 1,
max_fragment_combined_output_resources: 4294967295,
max_compute_shared_memory_size: 49152,
max_compute_work_group_count: [
2147483647,
65535,
65535,
],
max_compute_work_group_invocations: 1024,
max_compute_work_group_size: [
1024,
1024,
64,
],
sub_pixel_precision_bits: 8,
sub_texel_precision_bits: 8,
mipmap_precision_bits: 8,
max_draw_indexed_index_value: 4294967295,
max_draw_indirect_count: 4294967295,
max_sampler_lod_bias: 15.0,
max_sampler_anisotropy: 16.0,
max_viewports: 16,
max_viewport_dimensions: [
32768,
32768,
],
viewport_bounds_range: [
-65536.0,
65536.0,
],
viewport_sub_pixel_bits: 8,
min_memory_map_alignment: 64,
min_texel_buffer_offset_alignment: 16,
min_uniform_buffer_offset_alignment: 64,
min_storage_buffer_offset_alignment: 16,
min_texel_offset: -8,
max_texel_offset: 7,
min_texel_gather_offset: -32,
max_texel_gather_offset: 31,
min_interpolation_offset: -0.5,
max_interpolation_offset: 0.4375,
sub_pixel_interpolation_offset_bits: 4,
max_framebuffer_width: 32768,
max_framebuffer_height: 32768,
max_framebuffer_layers: 2048,
framebuffer_color_sample_counts: TYPE_1 | TYPE_2 | TYPE_4 | TYPE_8,
framebuffer_depth_sample_counts: TYPE_1 | TYPE_2 | TYPE_4 | TYPE_8,
framebuffer_stencil_sample_counts: TYPE_1 | TYPE_2 | TYPE_4 | TYPE_8 | TYPE_16,
framebuffer_no_attachments_sample_counts: TYPE_1 | TYPE_2 | TYPE_4 | TYPE_8 | TYPE_16,
max_color_attachments: 8,
sampled_image_color_sample_counts: TYPE_1 | TYPE_2 | TYPE_4 | TYPE_8,
sampled_image_integer_sample_counts: TYPE_1 | TYPE_2 | TYPE_4 | TYPE_8,
sampled_image_depth_sample_counts: TYPE_1 | TYPE_2 | TYPE_4 | TYPE_8,
sampled_image_stencil_sample_counts: TYPE_1 | TYPE_2 | TYPE_4 | TYPE_8 | TYPE_16,
storage_image_sample_counts: TYPE_1 | TYPE_2 | TYPE_4 | TYPE_8,
max_sample_mask_words: 1,
timestamp_compute_and_graphics: 1,
timestamp_period: 1.0,
max_clip_distances: 8,
max_cull_distances: 8,
max_combined_clip_and_cull_distances: 8,
discrete_queue_priorities: 2,
point_size_range: [
1.0,
2047.9375,
],
line_width_range: [
1.0,
64.0,
],
point_size_granularity: 0.0625,
line_width_granularity: 0.0625,
strict_lines: 1,
standard_sample_locations: 1,
optimal_buffer_copy_offset_alignment: 1,
optimal_buffer_copy_row_pitch_alignment: 1,
non_coherent_atom_size: 64,
},
sparse_properties: PhysicalDeviceSparseProperties {
residency_standard2_d_block_shape: 1,
residency_standard2_d_multisample_block_shape: 1,
residency_standard3_d_block_shape: 1,
residency_aligned_mip_size: 0,
residency_non_resident_strict: 1,
},
},
device_information: DeviceInformation {
is_software_emulated: false,
device_name: "NVIDIA GeForce RTX 4060",
driver_name: "NVIDIA",
driver_info: "590.48.01",
},
queue_family_index: 0,
layered: false,
ray_tracing: Some(
RayTracingCapabilities {
min_scratch_buffer_alignment: 128,
},
),
buffer_marker: true,
shader_info: false,
full_screen_exclusive: false,
external_memory: true,
timing: true,
bugs: SystemBugs {
intel_unable_to_present: false,
intel_fix_descriptor_pool_leak: false,
},
}
INFO RPC{rpc.trace_id=00 rpc.deadline=2026-01-12T19:09:29.975123286Z otel.kind="server"}: ReceiveRequest
INFO RPC{rpc.trace_id=00 rpc.deadline=2026-01-12T19:09:29.975123286Z otel.kind="server"}: BeginRequest
DEBUG SurfaceCapabilitiesKHR { min_image_count: 2, max_image_count: 8, current_extent: Extent2D { width: 4294967295, height: 4294967295 }, min_image_extent: Extent2D { width: 1, height: 1 }, max_image_extent: Extent2D { width: 16384, height: 16384 }, max_image_array_layers: 1, supported_transforms: IDENTITY, current_transform: IDENTITY, supported_composite_alpha: OPAQUE | PRE_MULTIPLIED, supported_usage_flags: TRANSFER_SRC | TRANSFER_DST | SAMPLED | STORAGE | COLOR_ATTACHMENT | INPUT_ATTACHMENT }
INFO Using surface present mode MAILBOX
INFO Creating a descriptor pool for at most 16 sets
INFO Creating a descriptor pool for at most 16 sets
INFO Initializing Blade pipelines for surface SurfaceInfo { format: Bgra8Unorm, alpha: PreMultiplied }
DEBUG Resolving [0] = FunctionArgument(0) : Handle([1])
DEBUG Resolving [1] = Literal(AbstractFloat(0.3)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [2] = Literal(AbstractFloat(0.59)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [3] = Literal(AbstractFloat(0.11)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [4] = Literal(F32(0.3)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [5] = Literal(F32(0.59)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [6] = Literal(F32(0.11)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [7] = Compose { ty: [1], components: [[4], [5], [6]] } : Handle([1])
DEBUG Initial overloads: List {
rules: [
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> {AbstractInt},
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> {AbstractFloat},
(vec2<i32>, vec2<i32>) -> i32,
(vec2<i64>, vec2<i64>) -> i64,
(vec2<u32>, vec2<u32>) -> u32,
(vec2<u64>, vec2<u64>) -> u64,
(vec2<f32>, vec2<f32>) -> f32,
(vec2<f16>, vec2<f16>) -> f16,
(vec2<f64>, vec2<f64>) -> f64,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> {AbstractInt},
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> {AbstractFloat},
(vec3<i32>, vec3<i32>) -> i32,
(vec3<i64>, vec3<i64>) -> i64,
(vec3<u32>, vec3<u32>) -> u32,
(vec3<u64>, vec3<u64>) -> u64,
(vec3<f32>, vec3<f32>) -> f32,
(vec3<f16>, vec3<f16>) -> f16,
(vec3<f64>, vec3<f64>) -> f64,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> {AbstractInt},
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> {AbstractFloat},
(vec4<i32>, vec4<i32>) -> i32,
(vec4<i64>, vec4<i64>) -> i64,
(vec4<u32>, vec4<u32>) -> u32,
(vec4<u64>, vec4<u64>) -> u64,
(vec4<f32>, vec4<f32>) -> f32,
(vec4<f16>, vec4<f16>) -> f16,
(vec4<f64>, vec4<f64>) -> f64,
],
conclude: Scalar,
}
DEBUG Supplying argument 0 of type vec3<f32>
DEBUG Remaining overloads: List {
rules: [
(vec3<f32>, vec3<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG Supplying argument 1 of type vec3<f32>
DEBUG Remaining overloads: List {
rules: [
(vec3<f32>, vec3<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG initial overloads for Dot, List {
rules: [
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> {AbstractInt},
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> {AbstractFloat},
(vec2<i32>, vec2<i32>) -> i32,
(vec2<i64>, vec2<i64>) -> i64,
(vec2<u32>, vec2<u32>) -> u32,
(vec2<u64>, vec2<u64>) -> u64,
(vec2<f32>, vec2<f32>) -> f32,
(vec2<f16>, vec2<f16>) -> f16,
(vec2<f64>, vec2<f64>) -> f64,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> {AbstractInt},
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> {AbstractFloat},
(vec3<i32>, vec3<i32>) -> i32,
(vec3<i64>, vec3<i64>) -> i64,
(vec3<u32>, vec3<u32>) -> u32,
(vec3<u64>, vec3<u64>) -> u64,
(vec3<f32>, vec3<f32>) -> f32,
(vec3<f16>, vec3<f16>) -> f16,
(vec3<f64>, vec3<f64>) -> f64,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> {AbstractInt},
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> {AbstractFloat},
(vec4<i32>, vec4<i32>) -> i32,
(vec4<i64>, vec4<i64>) -> i64,
(vec4<u32>, vec4<u32>) -> u32,
(vec4<u64>, vec4<u64>) -> u64,
(vec4<f32>, vec4<f32>) -> f32,
(vec4<f16>, vec4<f16>) -> f16,
(vec4<f64>, vec4<f64>) -> f64,
],
conclude: Scalar,
}
DEBUG overloads after arg 0 of type vec3<f32>: List {
rules: [
(vec3<f32>, vec3<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG overloads after arg 1 of type vec3<f32>: List {
rules: [
(vec3<f32>, vec3<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG Resolving [8] = Math { fun: Dot, arg: [0], arg1: Some([7]), arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [0] = FunctionArgument(0) : Handle([0])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([1])
DEBUG Resolving [2] = CallResult([0]) : Handle([0])
DEBUG Resolving [3] = Literal(AbstractFloat(4.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [4] = Literal(AbstractFloat(0.75)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [5] = Literal(F32(0.75)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [6] = Binary { op: Subtract, left: [5], right: [2] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [7] = Literal(F32(4.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [8] = Binary { op: Multiply, left: [7], right: [6] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Saturate, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [9] = Math { fun: Saturate, arg: [8], arg1: None, arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [10] = Binary { op: Multiply, left: [0], right: [9] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [0] = FunctionArgument(0) : Handle([0])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([0])
DEBUG Resolving [2] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [3] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [4] = Binary { op: Add, left: [1], right: [3] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [5] = Binary { op: Multiply, left: [0], right: [4] } : Handle([0])
DEBUG Resolving [6] = Binary { op: Multiply, left: [0], right: [1] } : Handle([0])
DEBUG Resolving [7] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [8] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [9] = Binary { op: Add, left: [6], right: [8] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [10] = Binary { op: Divide, left: [5], right: [9] } : Handle([0])
DEBUG Resolving [0] = FunctionArgument(0) : Handle([0])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([0])
DEBUG Resolving [2] = FunctionArgument(2) : Handle([2])
DEBUG Resolving [3] = AccessIndex { base: [2], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [4] = Binary { op: Multiply, left: [3], right: [1] } : Handle([0])
DEBUG Resolving [5] = AccessIndex { base: [2], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [6] = Binary { op: Add, left: [4], right: [5] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [7] = Binary { op: Multiply, left: [6], right: [0] } : Handle([0])
DEBUG Resolving [8] = AccessIndex { base: [2], index: 2 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [9] = Binary { op: Multiply, left: [8], right: [1] } : Handle([0])
DEBUG Resolving [10] = AccessIndex { base: [2], index: 3 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [11] = Binary { op: Add, left: [9], right: [10] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [12] = Binary { op: Add, left: [7], right: [11] } : Handle([0])
DEBUG Resolving [13] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [14] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [15] = Binary { op: Subtract, left: [14], right: [0] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [16] = Binary { op: Multiply, left: [0], right: [15] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [17] = Binary { op: Multiply, left: [16], right: [12] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [18] = Binary { op: Add, left: [0], right: [17] } : Handle([0])
DEBUG Resolving [0] = FunctionArgument(0) : Handle([0])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([1])
DEBUG Resolving [2] = FunctionArgument(2) : Handle([0])
DEBUG Resolving [3] = FunctionArgument(3) : Handle([2])
DEBUG Resolving [4] = CallResult([1]) : Handle([0])
DEBUG Resolving [5] = CallResult([0]) : Handle([0])
DEBUG Resolving [6] = CallResult([2]) : Handle([0])
DEBUG Resolving [7] = CallResult([3]) : Handle([0])
DEBUG Resolving [0] = Literal(AbstractFloat(3.1415926)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [1] = Literal(F32(3.1415925)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [2] = Literal(AbstractFloat(0.2126)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [3] = Literal(AbstractFloat(0.7152)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [4] = Literal(AbstractFloat(0.0722)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [5] = Literal(F32(0.2126)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [6] = Literal(F32(0.7152)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [7] = Literal(F32(0.0722)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [8] = Compose { ty: [1], components: [[5], [6], [7]] } : Handle([1])
DEBUG Resolving [9] = Literal(AbstractInt(2)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [0] = FunctionArgument(0) : Handle([3])
DEBUG Resolving [1] = GlobalVariable([0]) : Value(Pointer { base: [5], space: Uniform })
DEBUG Resolving [2] = AccessIndex { base: [1], index: 0 } : Value(Pointer { base: [3], space: Uniform })
DEBUG Resolving [3] = Load { pointer: [2] } : Handle([3])
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [4] = Binary { op: Divide, left: [0], right: [3] } : Handle([3])
DEBUG Resolving [5] = Literal(AbstractFloat(2.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [6] = Literal(AbstractFloat(2.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [7] = Literal(AbstractFloat(-2.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [8] = Literal(F32(2.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [9] = Literal(F32(-2.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [10] = Compose { ty: [3], components: [[8], [9]] } : Handle([3])
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [11] = Binary { op: Multiply, left: [4], right: [10] } : Handle([3])
DEBUG Resolving [12] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [13] = Literal(AbstractFloat(-1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [14] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [15] = Literal(F32(-1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [16] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [17] = Compose { ty: [3], components: [[15], [16]] } : Handle([3])
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [18] = Binary { op: Add, left: [11], right: [17] } : Handle([3])
DEBUG Resolving [19] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [20] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [21] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [22] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [23] = Compose { ty: [2], components: [[18], [21], [22]] } : Handle([2])
DEBUG Resolving [0] = FunctionArgument(0) : Handle([3])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([8])
DEBUG Resolving [2] = AccessIndex { base: [1], index: 1 } : Handle([3])
DEBUG Resolving [3] = As { expr: [2], kind: Float, convert: Some(4) } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [4] = Binary { op: Multiply, left: [0], right: [3] } : Handle([3])
DEBUG Resolving [5] = AccessIndex { base: [1], index: 0 } : Handle([3])
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [6] = Binary { op: Add, left: [4], right: [5] } : Handle([3])
DEBUG Resolving [7] = CallResult([5]) : Handle([2])
DEBUG Resolving [0] = FunctionArgument(0) : Handle([3])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([8])
DEBUG Resolving [2] = FunctionArgument(2) : Handle([21])
DEBUG Resolving [3] = AccessIndex { base: [1], index: 1 } : Handle([3])
DEBUG Resolving [4] = As { expr: [3], kind: Float, convert: Some(4) } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [5] = Binary { op: Multiply, left: [0], right: [4] } : Handle([3])
DEBUG Resolving [6] = AccessIndex { base: [1], index: 0 } : Handle([3])
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [7] = Binary { op: Add, left: [5], right: [6] } : Handle([3])
DEBUG Resolving [8] = AccessIndex { base: [2], index: 0 } : Handle([20])
DEBUG Initial overloads: [
(mat2x2<{AbstractFloat}>) -> mat2x2<{AbstractFloat}>,
(mat2x2<f32>) -> mat2x2<f32>,
(mat2x2<f16>) -> mat2x2<f16>,
(mat2x2<f64>) -> mat2x2<f64>,
(mat2x3<{AbstractFloat}>) -> mat3x2<{AbstractFloat}>,
(mat2x3<f32>) -> mat3x2<f32>,
(mat2x3<f16>) -> mat3x2<f16>,
(mat2x3<f64>) -> mat3x2<f64>,
(mat2x4<{AbstractFloat}>) -> mat4x2<{AbstractFloat}>,
(mat2x4<f32>) -> mat4x2<f32>,
(mat2x4<f16>) -> mat4x2<f16>,
(mat2x4<f64>) -> mat4x2<f64>,
(mat3x2<{AbstractFloat}>) -> mat2x3<{AbstractFloat}>,
(mat3x2<f32>) -> mat2x3<f32>,
(mat3x2<f16>) -> mat2x3<f16>,
(mat3x2<f64>) -> mat2x3<f64>,
(mat3x3<{AbstractFloat}>) -> mat3x3<{AbstractFloat}>,
(mat3x3<f32>) -> mat3x3<f32>,
(mat3x3<f16>) -> mat3x3<f16>,
(mat3x3<f64>) -> mat3x3<f64>,
(mat3x4<{AbstractFloat}>) -> mat4x3<{AbstractFloat}>,
(mat3x4<f32>) -> mat4x3<f32>,
(mat3x4<f16>) -> mat4x3<f16>,
(mat3x4<f64>) -> mat4x3<f64>,
(mat4x2<{AbstractFloat}>) -> mat2x4<{AbstractFloat}>,
(mat4x2<f32>) -> mat2x4<f32>,
(mat4x2<f16>) -> mat2x4<f16>,
(mat4x2<f64>) -> mat2x4<f64>,
(mat4x3<{AbstractFloat}>) -> mat3x4<{AbstractFloat}>,
(mat4x3<f32>) -> mat3x4<f32>,
(mat4x3<f16>) -> mat3x4<f16>,
(mat4x3<f64>) -> mat3x4<f64>,
(mat4x4<{AbstractFloat}>) -> mat4x4<{AbstractFloat}>,
(mat4x4<f32>) -> mat4x4<f32>,
(mat4x4<f16>) -> mat4x4<f16>,
(mat4x4<f64>) -> mat4x4<f64>,
]
DEBUG Supplying argument 0 of type mat2x2<f32>
DEBUG arg 0 of type mat2x2<f32>
DEBUG considering rule (mat2x2<{AbstractFloat}>) -> mat2x2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat2x2<f32>) -> mat2x2<f32>
DEBUG types are equivalent
DEBUG considering rule (mat2x2<f16>) -> mat2x2<f16>
DEBUG no conversion possible
DEBUG considering rule (mat2x2<f64>) -> mat2x2<f64>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<{AbstractFloat}>) -> mat3x2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<f32>) -> mat3x2<f32>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<f16>) -> mat3x2<f16>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<f64>) -> mat3x2<f64>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<{AbstractFloat}>) -> mat4x2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<f32>) -> mat4x2<f32>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<f16>) -> mat4x2<f16>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<f64>) -> mat4x2<f64>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<{AbstractFloat}>) -> mat2x3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<f32>) -> mat2x3<f32>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<f16>) -> mat2x3<f16>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<f64>) -> mat2x3<f64>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<{AbstractFloat}>) -> mat3x3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<f32>) -> mat3x3<f32>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<f16>) -> mat3x3<f16>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<f64>) -> mat3x3<f64>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<{AbstractFloat}>) -> mat4x3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<f32>) -> mat4x3<f32>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<f16>) -> mat4x3<f16>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<f64>) -> mat4x3<f64>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<{AbstractFloat}>) -> mat2x4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<f32>) -> mat2x4<f32>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<f16>) -> mat2x4<f16>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<f64>) -> mat2x4<f64>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<{AbstractFloat}>) -> mat3x4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<f32>) -> mat3x4<f32>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<f16>) -> mat3x4<f16>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<f64>) -> mat3x4<f64>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<{AbstractFloat}>) -> mat4x4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<f32>) -> mat4x4<f32>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<f16>) -> mat4x4<f16>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<f64>) -> mat4x4<f64>
DEBUG no conversion possible
DEBUG Remaining overloads: [
(mat2x2<f32>) -> mat2x2<f32>,
]
DEBUG initial overloads for Transpose, [
(mat2x2<{AbstractFloat}>) -> mat2x2<{AbstractFloat}>,
(mat2x2<f32>) -> mat2x2<f32>,
(mat2x2<f16>) -> mat2x2<f16>,
(mat2x2<f64>) -> mat2x2<f64>,
(mat2x3<{AbstractFloat}>) -> mat3x2<{AbstractFloat}>,
(mat2x3<f32>) -> mat3x2<f32>,
(mat2x3<f16>) -> mat3x2<f16>,
(mat2x3<f64>) -> mat3x2<f64>,
(mat2x4<{AbstractFloat}>) -> mat4x2<{AbstractFloat}>,
(mat2x4<f32>) -> mat4x2<f32>,
(mat2x4<f16>) -> mat4x2<f16>,
(mat2x4<f64>) -> mat4x2<f64>,
(mat3x2<{AbstractFloat}>) -> mat2x3<{AbstractFloat}>,
(mat3x2<f32>) -> mat2x3<f32>,
(mat3x2<f16>) -> mat2x3<f16>,
(mat3x2<f64>) -> mat2x3<f64>,
(mat3x3<{AbstractFloat}>) -> mat3x3<{AbstractFloat}>,
(mat3x3<f32>) -> mat3x3<f32>,
(mat3x3<f16>) -> mat3x3<f16>,
(mat3x3<f64>) -> mat3x3<f64>,
(mat3x4<{AbstractFloat}>) -> mat4x3<{AbstractFloat}>,
(mat3x4<f32>) -> mat4x3<f32>,
(mat3x4<f16>) -> mat4x3<f16>,
(mat3x4<f64>) -> mat4x3<f64>,
(mat4x2<{AbstractFloat}>) -> mat2x4<{AbstractFloat}>,
(mat4x2<f32>) -> mat2x4<f32>,
(mat4x2<f16>) -> mat2x4<f16>,
(mat4x2<f64>) -> mat2x4<f64>,
(mat4x3<{AbstractFloat}>) -> mat3x4<{AbstractFloat}>,
(mat4x3<f32>) -> mat3x4<f32>,
(mat4x3<f16>) -> mat3x4<f16>,
(mat4x3<f64>) -> mat3x4<f64>,
(mat4x4<{AbstractFloat}>) -> mat4x4<{AbstractFloat}>,
(mat4x4<f32>) -> mat4x4<f32>,
(mat4x4<f16>) -> mat4x4<f16>,
(mat4x4<f64>) -> mat4x4<f64>,
]
DEBUG arg 0 of type mat2x2<f32>
DEBUG considering rule (mat2x2<{AbstractFloat}>) -> mat2x2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat2x2<f32>) -> mat2x2<f32>
DEBUG types are equivalent
DEBUG considering rule (mat2x2<f16>) -> mat2x2<f16>
DEBUG no conversion possible
DEBUG considering rule (mat2x2<f64>) -> mat2x2<f64>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<{AbstractFloat}>) -> mat3x2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<f32>) -> mat3x2<f32>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<f16>) -> mat3x2<f16>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<f64>) -> mat3x2<f64>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<{AbstractFloat}>) -> mat4x2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<f32>) -> mat4x2<f32>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<f16>) -> mat4x2<f16>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<f64>) -> mat4x2<f64>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<{AbstractFloat}>) -> mat2x3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<f32>) -> mat2x3<f32>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<f16>) -> mat2x3<f16>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<f64>) -> mat2x3<f64>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<{AbstractFloat}>) -> mat3x3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<f32>) -> mat3x3<f32>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<f16>) -> mat3x3<f16>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<f64>) -> mat3x3<f64>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<{AbstractFloat}>) -> mat4x3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<f32>) -> mat4x3<f32>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<f16>) -> mat4x3<f16>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<f64>) -> mat4x3<f64>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<{AbstractFloat}>) -> mat2x4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<f32>) -> mat2x4<f32>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<f16>) -> mat2x4<f16>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<f64>) -> mat2x4<f64>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<{AbstractFloat}>) -> mat3x4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<f32>) -> mat3x4<f32>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<f16>) -> mat3x4<f16>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<f64>) -> mat3x4<f64>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<{AbstractFloat}>) -> mat4x4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<f32>) -> mat4x4<f32>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<f16>) -> mat4x4<f16>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<f64>) -> mat4x4<f64>
DEBUG no conversion possible
DEBUG overloads after arg 0 of type mat2x2<f32>: [
(mat2x2<f32>) -> mat2x2<f32>,
]
DEBUG Resolving [9] = Math { fun: Transpose, arg: [8], arg1: None, arg2: None, arg3: None } : Value(Matrix { columns: Bi, rows: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: mat2x2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [10] = Binary { op: Multiply, left: [9], right: [7] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [11] = AccessIndex { base: [2], index: 1 } : Handle([3])
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [12] = Binary { op: Add, left: [10], right: [11] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [13] = CallResult([5]) : Handle([2])
DEBUG Resolving [0] = FunctionArgument(0) : Handle([3])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([19])
DEBUG Resolving [2] = GlobalVariable([3]) : Handle([6])
DEBUG Resolving [3] = Literal(AbstractInt(0)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [4] = Literal(I32(0)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [5] = ImageQuery { image: [2], query: Size { level: Some([4]) } } : Value(Vector { size: Bi, scalar: Scalar { kind: Uint, width: 4 } })
DEBUG Resolving [6] = As { expr: [5], kind: Float, convert: Some(4) } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [7] = AccessIndex { base: [1], index: 3 } : Handle([18])
DEBUG Resolving [8] = AccessIndex { base: [7], index: 0 } : Handle([17])
DEBUG Resolving [9] = As { expr: [8], kind: Float, convert: Some(4) } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [10] = AccessIndex { base: [1], index: 3 } : Handle([18])
DEBUG Resolving [11] = AccessIndex { base: [10], index: 1 } : Handle([17])
DEBUG Resolving [12] = As { expr: [11], kind: Float, convert: Some(4) } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [13] = Binary { op: Multiply, left: [0], right: [12] } : Handle([3])
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [14] = Binary { op: Add, left: [9], right: [13] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [15] = Binary { op: Divide, left: [14], right: [6] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [0] = FunctionArgument(0) : Handle([3])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([8])
DEBUG Resolving [2] = AccessIndex { base: [1], index: 0 } : Handle([3])
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [3] = Binary { op: Subtract, left: [0], right: [2] } : Handle([3])
DEBUG Resolving [4] = AccessIndex { base: [1], index: 0 } : Handle([3])
DEBUG Resolving [5] = AccessIndex { base: [1], index: 1 } : Handle([3])
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [6] = Binary { op: Add, left: [4], right: [5] } : Handle([3])
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [7] = Binary { op: Subtract, left: [6], right: [0] } : Handle([3])
DEBUG Resolving [8] = AccessIndex { base: [3], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [9] = AccessIndex { base: [7], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [10] = AccessIndex { base: [3], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [11] = AccessIndex { base: [7], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [12] = Compose { ty: [2], components: [[8], [9], [10], [11]] } : Handle([2])
DEBUG Resolving [0] = FunctionArgument(0) : Handle([3])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([8])
DEBUG Resolving [2] = FunctionArgument(2) : Handle([8])
DEBUG Resolving [3] = AccessIndex { base: [1], index: 1 } : Handle([3])
DEBUG Resolving [4] = As { expr: [3], kind: Float, convert: Some(4) } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [5] = Binary { op: Multiply, left: [0], right: [4] } : Handle([3])
DEBUG Resolving [6] = AccessIndex { base: [1], index: 0 } : Handle([3])
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [7] = Binary { op: Add, left: [5], right: [6] } : Handle([3])
DEBUG Resolving [8] = CallResult([9]) : Handle([2])
DEBUG Resolving [0] = FunctionArgument(0) : Handle([3])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([8])
DEBUG Resolving [2] = FunctionArgument(2) : Handle([8])
DEBUG Resolving [3] = FunctionArgument(3) : Handle([21])
DEBUG Resolving [4] = AccessIndex { base: [1], index: 1 } : Handle([3])
DEBUG Resolving [5] = As { expr: [4], kind: Float, convert: Some(4) } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [6] = Binary { op: Multiply, left: [0], right: [5] } : Handle([3])
DEBUG Resolving [7] = AccessIndex { base: [1], index: 0 } : Handle([3])
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [8] = Binary { op: Add, left: [6], right: [7] } : Handle([3])
DEBUG Resolving [9] = AccessIndex { base: [3], index: 0 } : Handle([20])
DEBUG Initial overloads: [
(mat2x2<{AbstractFloat}>) -> mat2x2<{AbstractFloat}>,
(mat2x2<f32>) -> mat2x2<f32>,
(mat2x2<f16>) -> mat2x2<f16>,
(mat2x2<f64>) -> mat2x2<f64>,
(mat2x3<{AbstractFloat}>) -> mat3x2<{AbstractFloat}>,
(mat2x3<f32>) -> mat3x2<f32>,
(mat2x3<f16>) -> mat3x2<f16>,
(mat2x3<f64>) -> mat3x2<f64>,
(mat2x4<{AbstractFloat}>) -> mat4x2<{AbstractFloat}>,
(mat2x4<f32>) -> mat4x2<f32>,
(mat2x4<f16>) -> mat4x2<f16>,
(mat2x4<f64>) -> mat4x2<f64>,
(mat3x2<{AbstractFloat}>) -> mat2x3<{AbstractFloat}>,
(mat3x2<f32>) -> mat2x3<f32>,
(mat3x2<f16>) -> mat2x3<f16>,
(mat3x2<f64>) -> mat2x3<f64>,
(mat3x3<{AbstractFloat}>) -> mat3x3<{AbstractFloat}>,
(mat3x3<f32>) -> mat3x3<f32>,
(mat3x3<f16>) -> mat3x3<f16>,
(mat3x3<f64>) -> mat3x3<f64>,
(mat3x4<{AbstractFloat}>) -> mat4x3<{AbstractFloat}>,
(mat3x4<f32>) -> mat4x3<f32>,
(mat3x4<f16>) -> mat4x3<f16>,
(mat3x4<f64>) -> mat4x3<f64>,
(mat4x2<{AbstractFloat}>) -> mat2x4<{AbstractFloat}>,
(mat4x2<f32>) -> mat2x4<f32>,
(mat4x2<f16>) -> mat2x4<f16>,
(mat4x2<f64>) -> mat2x4<f64>,
(mat4x3<{AbstractFloat}>) -> mat3x4<{AbstractFloat}>,
(mat4x3<f32>) -> mat3x4<f32>,
(mat4x3<f16>) -> mat3x4<f16>,
(mat4x3<f64>) -> mat3x4<f64>,
(mat4x4<{AbstractFloat}>) -> mat4x4<{AbstractFloat}>,
(mat4x4<f32>) -> mat4x4<f32>,
(mat4x4<f16>) -> mat4x4<f16>,
(mat4x4<f64>) -> mat4x4<f64>,
]
DEBUG Supplying argument 0 of type mat2x2<f32>
DEBUG arg 0 of type mat2x2<f32>
DEBUG considering rule (mat2x2<{AbstractFloat}>) -> mat2x2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat2x2<f32>) -> mat2x2<f32>
DEBUG types are equivalent
DEBUG considering rule (mat2x2<f16>) -> mat2x2<f16>
DEBUG no conversion possible
DEBUG considering rule (mat2x2<f64>) -> mat2x2<f64>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<{AbstractFloat}>) -> mat3x2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<f32>) -> mat3x2<f32>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<f16>) -> mat3x2<f16>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<f64>) -> mat3x2<f64>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<{AbstractFloat}>) -> mat4x2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<f32>) -> mat4x2<f32>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<f16>) -> mat4x2<f16>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<f64>) -> mat4x2<f64>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<{AbstractFloat}>) -> mat2x3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<f32>) -> mat2x3<f32>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<f16>) -> mat2x3<f16>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<f64>) -> mat2x3<f64>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<{AbstractFloat}>) -> mat3x3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<f32>) -> mat3x3<f32>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<f16>) -> mat3x3<f16>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<f64>) -> mat3x3<f64>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<{AbstractFloat}>) -> mat4x3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<f32>) -> mat4x3<f32>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<f16>) -> mat4x3<f16>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<f64>) -> mat4x3<f64>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<{AbstractFloat}>) -> mat2x4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<f32>) -> mat2x4<f32>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<f16>) -> mat2x4<f16>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<f64>) -> mat2x4<f64>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<{AbstractFloat}>) -> mat3x4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<f32>) -> mat3x4<f32>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<f16>) -> mat3x4<f16>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<f64>) -> mat3x4<f64>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<{AbstractFloat}>) -> mat4x4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<f32>) -> mat4x4<f32>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<f16>) -> mat4x4<f16>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<f64>) -> mat4x4<f64>
DEBUG no conversion possible
DEBUG Remaining overloads: [
(mat2x2<f32>) -> mat2x2<f32>,
]
DEBUG initial overloads for Transpose, [
(mat2x2<{AbstractFloat}>) -> mat2x2<{AbstractFloat}>,
(mat2x2<f32>) -> mat2x2<f32>,
(mat2x2<f16>) -> mat2x2<f16>,
(mat2x2<f64>) -> mat2x2<f64>,
(mat2x3<{AbstractFloat}>) -> mat3x2<{AbstractFloat}>,
(mat2x3<f32>) -> mat3x2<f32>,
(mat2x3<f16>) -> mat3x2<f16>,
(mat2x3<f64>) -> mat3x2<f64>,
(mat2x4<{AbstractFloat}>) -> mat4x2<{AbstractFloat}>,
(mat2x4<f32>) -> mat4x2<f32>,
(mat2x4<f16>) -> mat4x2<f16>,
(mat2x4<f64>) -> mat4x2<f64>,
(mat3x2<{AbstractFloat}>) -> mat2x3<{AbstractFloat}>,
(mat3x2<f32>) -> mat2x3<f32>,
(mat3x2<f16>) -> mat2x3<f16>,
(mat3x2<f64>) -> mat2x3<f64>,
(mat3x3<{AbstractFloat}>) -> mat3x3<{AbstractFloat}>,
(mat3x3<f32>) -> mat3x3<f32>,
(mat3x3<f16>) -> mat3x3<f16>,
(mat3x3<f64>) -> mat3x3<f64>,
(mat3x4<{AbstractFloat}>) -> mat4x3<{AbstractFloat}>,
(mat3x4<f32>) -> mat4x3<f32>,
(mat3x4<f16>) -> mat4x3<f16>,
(mat3x4<f64>) -> mat4x3<f64>,
(mat4x2<{AbstractFloat}>) -> mat2x4<{AbstractFloat}>,
(mat4x2<f32>) -> mat2x4<f32>,
(mat4x2<f16>) -> mat2x4<f16>,
(mat4x2<f64>) -> mat2x4<f64>,
(mat4x3<{AbstractFloat}>) -> mat3x4<{AbstractFloat}>,
(mat4x3<f32>) -> mat3x4<f32>,
(mat4x3<f16>) -> mat3x4<f16>,
(mat4x3<f64>) -> mat3x4<f64>,
(mat4x4<{AbstractFloat}>) -> mat4x4<{AbstractFloat}>,
(mat4x4<f32>) -> mat4x4<f32>,
(mat4x4<f16>) -> mat4x4<f16>,
(mat4x4<f64>) -> mat4x4<f64>,
]
DEBUG arg 0 of type mat2x2<f32>
DEBUG considering rule (mat2x2<{AbstractFloat}>) -> mat2x2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat2x2<f32>) -> mat2x2<f32>
DEBUG types are equivalent
DEBUG considering rule (mat2x2<f16>) -> mat2x2<f16>
DEBUG no conversion possible
DEBUG considering rule (mat2x2<f64>) -> mat2x2<f64>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<{AbstractFloat}>) -> mat3x2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<f32>) -> mat3x2<f32>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<f16>) -> mat3x2<f16>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<f64>) -> mat3x2<f64>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<{AbstractFloat}>) -> mat4x2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<f32>) -> mat4x2<f32>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<f16>) -> mat4x2<f16>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<f64>) -> mat4x2<f64>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<{AbstractFloat}>) -> mat2x3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<f32>) -> mat2x3<f32>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<f16>) -> mat2x3<f16>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<f64>) -> mat2x3<f64>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<{AbstractFloat}>) -> mat3x3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<f32>) -> mat3x3<f32>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<f16>) -> mat3x3<f16>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<f64>) -> mat3x3<f64>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<{AbstractFloat}>) -> mat4x3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<f32>) -> mat4x3<f32>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<f16>) -> mat4x3<f16>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<f64>) -> mat4x3<f64>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<{AbstractFloat}>) -> mat2x4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<f32>) -> mat2x4<f32>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<f16>) -> mat2x4<f16>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<f64>) -> mat2x4<f64>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<{AbstractFloat}>) -> mat3x4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<f32>) -> mat3x4<f32>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<f16>) -> mat3x4<f16>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<f64>) -> mat3x4<f64>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<{AbstractFloat}>) -> mat4x4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<f32>) -> mat4x4<f32>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<f16>) -> mat4x4<f16>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<f64>) -> mat4x4<f64>
DEBUG no conversion possible
DEBUG overloads after arg 0 of type mat2x2<f32>: [
(mat2x2<f32>) -> mat2x2<f32>,
]
DEBUG Resolving [10] = Math { fun: Transpose, arg: [9], arg1: None, arg2: None, arg3: None } : Value(Matrix { columns: Bi, rows: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: mat2x2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [11] = Binary { op: Multiply, left: [10], right: [8] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [12] = AccessIndex { base: [3], index: 1 } : Handle([3])
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [13] = Binary { op: Add, left: [11], right: [12] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [14] = CallResult([9]) : Handle([2])
DEBUG Resolving [0] = FunctionArgument(0) : Handle([1])
DEBUG Resolving [1] = Literal(AbstractFloat(0.04045)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [2] = Literal(F32(0.04045)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [3] = Splat { size: Tri, value: [2] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec3<f32>, vec3<f32>
DEBUG consensus: f32
DEBUG Resolving [4] = Binary { op: Less, left: [0], right: [3] } : Value(Vector { size: Tri, scalar: Scalar { kind: Bool, width: 1 } })
DEBUG Resolving [5] = Literal(AbstractFloat(0.055)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [6] = Literal(F32(0.055)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [7] = Splat { size: Tri, value: [6] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec3<f32>, vec3<f32>
DEBUG consensus: f32
DEBUG Resolving [8] = Binary { op: Add, left: [0], right: [7] } : Handle([1])
DEBUG Resolving [9] = Literal(AbstractFloat(1.055)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [10] = Literal(F32(1.055)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [11] = Splat { size: Tri, value: [10] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec3<f32>, vec3<f32>
DEBUG consensus: f32
DEBUG Resolving [12] = Binary { op: Divide, left: [8], right: [11] } : Handle([1])
DEBUG Resolving [13] = Literal(AbstractFloat(2.4)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [14] = Literal(F32(2.4)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [15] = Splat { size: Tri, value: [14] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type vec3<f32>
DEBUG Remaining overloads: List {
rules: [
(vec3<f32>, vec3<f32>) -> vec3<f32>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 1 of type vec3<f32>
DEBUG Remaining overloads: List {
rules: [
(vec3<f32>, vec3<f32>) -> vec3<f32>,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Pow, List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type vec3<f32>: List {
rules: [
(vec3<f32>, vec3<f32>) -> vec3<f32>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type vec3<f32>: List {
rules: [
(vec3<f32>, vec3<f32>) -> vec3<f32>,
],
conclude: ArgumentType,
}
DEBUG Resolving [16] = Math { fun: Pow, arg: [12], arg1: Some([15]), arg2: None, arg3: None } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [17] = Literal(AbstractFloat(12.92)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [18] = Literal(F32(12.92)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [19] = Splat { size: Tri, value: [18] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec3<f32>, vec3<f32>
DEBUG consensus: f32
DEBUG Resolving [20] = Binary { op: Divide, left: [0], right: [19] } : Handle([1])
DEBUG Resolving [21] = Select { condition: [4], accept: [20], reject: [16] } : Handle([1])
DEBUG Resolving [0] = FunctionArgument(0) : Handle([0])
DEBUG Resolving [1] = Literal(AbstractFloat(0.04045)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [2] = Literal(F32(0.04045)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [3] = Binary { op: Less, left: [0], right: [2] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [4] = Literal(AbstractFloat(0.055)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [5] = Literal(F32(0.055)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [6] = Binary { op: Add, left: [0], right: [5] } : Handle([0])
DEBUG Resolving [7] = Literal(AbstractFloat(1.055)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [8] = Literal(F32(1.055)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [9] = Binary { op: Divide, left: [6], right: [8] } : Handle([0])
DEBUG Resolving [10] = Literal(AbstractFloat(2.4)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 1 of type {AbstractFloat}
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [11] = Literal(F32(2.4)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG initial overloads for Pow, List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [12] = Math { fun: Pow, arg: [9], arg1: Some([11]), arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [13] = Literal(AbstractFloat(12.92)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [14] = Literal(F32(12.92)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [15] = Binary { op: Divide, left: [0], right: [14] } : Handle([0])
DEBUG Resolving [16] = Select { condition: [3], accept: [15], reject: [12] } : Handle([0])
DEBUG Resolving [0] = FunctionArgument(0) : Handle([1])
DEBUG Resolving [1] = Literal(AbstractFloat(0.0031308)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [2] = Literal(F32(0.0031308)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [3] = Splat { size: Tri, value: [2] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec3<f32>, vec3<f32>
DEBUG consensus: f32
DEBUG Resolving [4] = Binary { op: Less, left: [0], right: [3] } : Value(Vector { size: Tri, scalar: Scalar { kind: Bool, width: 1 } })
DEBUG Resolving [5] = Literal(AbstractFloat(1.055)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [6] = Literal(F32(1.055)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [7] = Splat { size: Tri, value: [6] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [8] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [9] = Literal(AbstractFloat(2.4)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, {AbstractFloat}
DEBUG consensus: {AbstractFloat}
DEBUG Resolving [10] = Literal(AbstractFloat(0.4166666666666667)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [11] = Literal(F32(0.41666666)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [12] = Splat { size: Tri, value: [11] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type vec3<f32>
DEBUG Remaining overloads: List {
rules: [
(vec3<f32>, vec3<f32>) -> vec3<f32>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 1 of type vec3<f32>
DEBUG Remaining overloads: List {
rules: [
(vec3<f32>, vec3<f32>) -> vec3<f32>,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Pow, List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type vec3<f32>: List {
rules: [
(vec3<f32>, vec3<f32>) -> vec3<f32>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type vec3<f32>: List {
rules: [
(vec3<f32>, vec3<f32>) -> vec3<f32>,
],
conclude: ArgumentType,
}
DEBUG Resolving [13] = Math { fun: Pow, arg: [0], arg1: Some([12]), arg2: None, arg3: None } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec3<f32>, vec3<f32>
DEBUG consensus: f32
DEBUG Resolving [14] = Binary { op: Multiply, left: [7], right: [13] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [15] = Literal(AbstractFloat(0.055)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [16] = Literal(F32(0.055)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [17] = Splat { size: Tri, value: [16] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec3<f32>, vec3<f32>
DEBUG consensus: f32
DEBUG Resolving [18] = Binary { op: Subtract, left: [14], right: [17] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [19] = Literal(AbstractFloat(12.92)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [20] = Literal(F32(12.92)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [21] = Splat { size: Tri, value: [20] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec3<f32>, vec3<f32>
DEBUG consensus: f32
DEBUG Resolving [22] = Binary { op: Multiply, left: [0], right: [21] } : Handle([1])
DEBUG Resolving [23] = Select { condition: [4], accept: [22], reject: [18] } : Handle([1])
DEBUG Resolving [0] = FunctionArgument(0) : Handle([2])
DEBUG Resolving [1] = Swizzle { size: Tri, vector: [0], pattern: [X, Y, Z, X] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [2] = CallResult([14]) : Handle([1])
DEBUG Resolving [3] = AccessIndex { base: [0], index: 3 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [4] = Compose { ty: [2], components: [[2], [3]] } : Handle([2])
DEBUG Resolving [0] = FunctionArgument(0) : Handle([2])
DEBUG Resolving [1] = Swizzle { size: Tri, vector: [0], pattern: [X, Y, Z, X] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [2] = CallResult([12]) : Handle([1])
DEBUG Resolving [3] = AccessIndex { base: [0], index: 3 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [4] = Compose { ty: [2], components: [[2], [3]] } : Handle([2])
DEBUG Resolving [0] = FunctionArgument(0) : Handle([11])
DEBUG Resolving [1] = AccessIndex { base: [0], index: 0 } : Handle([0])
DEBUG Resolving [2] = Literal(AbstractFloat(6.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [3] = Literal(F32(6.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [4] = Binary { op: Multiply, left: [1], right: [3] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [5] = AccessIndex { base: [0], index: 1 } : Handle([0])
DEBUG Resolving [6] = AccessIndex { base: [0], index: 2 } : Handle([0])
DEBUG Resolving [7] = AccessIndex { base: [0], index: 3 } : Handle([0])
DEBUG Resolving [8] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [9] = Literal(AbstractFloat(2.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [10] = Literal(F32(2.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [11] = Binary { op: Multiply, left: [10], right: [6] } : Handle([0])
DEBUG Resolving [12] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [13] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [14] = Binary { op: Subtract, left: [11], right: [13] } : Handle([0])
DEBUG Initial overloads: List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Abs, List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [15] = Math { fun: Abs, arg: [14], arg1: None, arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [16] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [17] = Binary { op: Subtract, left: [16], right: [15] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [18] = Binary { op: Multiply, left: [17], right: [5] } : Handle([0])
DEBUG Resolving [19] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [20] = Literal(AbstractFloat(2.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [21] = Literal(F32(2.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [22] = Binary { op: Modulo, left: [4], right: [21] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [23] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [24] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [25] = Binary { op: Subtract, left: [22], right: [24] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Initial overloads: List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Abs, List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [26] = Math { fun: Abs, arg: [25], arg1: None, arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [27] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [28] = Binary { op: Subtract, left: [27], right: [26] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [29] = Binary { op: Multiply, left: [18], right: [28] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [30] = Literal(AbstractFloat(2.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [31] = Literal(F32(2.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [32] = Binary { op: Divide, left: [18], right: [31] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [33] = Binary { op: Subtract, left: [6], right: [32] } : Handle([0])
DEBUG Resolving [34] = Splat { size: Tri, value: [33] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [35] = LocalVariable([0]) : Value(Pointer { base: [1], space: Function })
DEBUG Resolving [36] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [37] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [38] = Binary { op: GreaterEqual, left: [4], right: [37] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [39] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [40] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [41] = Binary { op: Less, left: [4], right: [40] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG wgsl automatic_conversion_consensus: bool, bool
DEBUG consensus: bool
DEBUG Resolving [42] = Binary { op: LogicalAnd, left: [38], right: [41] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [43] = AccessIndex { base: [35], index: 0 } : Value(ValuePointer { size: None, scalar: Scalar { kind: Float, width: 4 }, space: Function })
DEBUG Resolving [44] = Load { pointer: [43] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [45] = Binary { op: Add, left: [44], right: [18] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [46] = AccessIndex { base: [35], index: 1 } : Value(ValuePointer { size: None, scalar: Scalar { kind: Float, width: 4 }, space: Function })
DEBUG Resolving [47] = Load { pointer: [46] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [48] = Binary { op: Add, left: [47], right: [29] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [49] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [50] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [51] = Binary { op: GreaterEqual, left: [4], right: [50] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [52] = Literal(AbstractFloat(2.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [53] = Literal(F32(2.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [54] = Binary { op: Less, left: [4], right: [53] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG wgsl automatic_conversion_consensus: bool, bool
DEBUG consensus: bool
DEBUG Resolving [55] = Binary { op: LogicalAnd, left: [51], right: [54] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [56] = AccessIndex { base: [35], index: 0 } : Value(ValuePointer { size: None, scalar: Scalar { kind: Float, width: 4 }, space: Function })
DEBUG Resolving [57] = Load { pointer: [56] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [58] = Binary { op: Add, left: [57], right: [29] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [59] = AccessIndex { base: [35], index: 1 } : Value(ValuePointer { size: None, scalar: Scalar { kind: Float, width: 4 }, space: Function })
DEBUG Resolving [60] = Load { pointer: [59] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [61] = Binary { op: Add, left: [60], right: [18] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [62] = Literal(AbstractFloat(2.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [63] = Literal(F32(2.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [64] = Binary { op: GreaterEqual, left: [4], right: [63] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [65] = Literal(AbstractFloat(3.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [66] = Literal(F32(3.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [67] = Binary { op: Less, left: [4], right: [66] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG wgsl automatic_conversion_consensus: bool, bool
DEBUG consensus: bool
DEBUG Resolving [68] = Binary { op: LogicalAnd, left: [64], right: [67] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [69] = AccessIndex { base: [35], index: 1 } : Value(ValuePointer { size: None, scalar: Scalar { kind: Float, width: 4 }, space: Function })
DEBUG Resolving [70] = Load { pointer: [69] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [71] = Binary { op: Add, left: [70], right: [18] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [72] = AccessIndex { base: [35], index: 2 } : Value(ValuePointer { size: None, scalar: Scalar { kind: Float, width: 4 }, space: Function })
DEBUG Resolving [73] = Load { pointer: [72] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [74] = Binary { op: Add, left: [73], right: [29] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [75] = Literal(AbstractFloat(3.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [76] = Literal(F32(3.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [77] = Binary { op: GreaterEqual, left: [4], right: [76] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [78] = Literal(AbstractFloat(4.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [79] = Literal(F32(4.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [80] = Binary { op: Less, left: [4], right: [79] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG wgsl automatic_conversion_consensus: bool, bool
DEBUG consensus: bool
DEBUG Resolving [81] = Binary { op: LogicalAnd, left: [77], right: [80] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [82] = AccessIndex { base: [35], index: 1 } : Value(ValuePointer { size: None, scalar: Scalar { kind: Float, width: 4 }, space: Function })
DEBUG Resolving [83] = Load { pointer: [82] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [84] = Binary { op: Add, left: [83], right: [29] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [85] = AccessIndex { base: [35], index: 2 } : Value(ValuePointer { size: None, scalar: Scalar { kind: Float, width: 4 }, space: Function })
DEBUG Resolving [86] = Load { pointer: [85] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [87] = Binary { op: Add, left: [86], right: [18] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [88] = Literal(AbstractFloat(4.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [89] = Literal(F32(4.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [90] = Binary { op: GreaterEqual, left: [4], right: [89] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [91] = Literal(AbstractFloat(5.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [92] = Literal(F32(5.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [93] = Binary { op: Less, left: [4], right: [92] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG wgsl automatic_conversion_consensus: bool, bool
DEBUG consensus: bool
DEBUG Resolving [94] = Binary { op: LogicalAnd, left: [90], right: [93] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [95] = AccessIndex { base: [35], index: 0 } : Value(ValuePointer { size: None, scalar: Scalar { kind: Float, width: 4 }, space: Function })
DEBUG Resolving [96] = Load { pointer: [95] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [97] = Binary { op: Add, left: [96], right: [29] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [98] = AccessIndex { base: [35], index: 2 } : Value(ValuePointer { size: None, scalar: Scalar { kind: Float, width: 4 }, space: Function })
DEBUG Resolving [99] = Load { pointer: [98] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [100] = Binary { op: Add, left: [99], right: [18] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [101] = AccessIndex { base: [35], index: 0 } : Value(ValuePointer { size: None, scalar: Scalar { kind: Float, width: 4 }, space: Function })
DEBUG Resolving [102] = Load { pointer: [101] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [103] = Binary { op: Add, left: [102], right: [18] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [104] = AccessIndex { base: [35], index: 2 } : Value(ValuePointer { size: None, scalar: Scalar { kind: Float, width: 4 }, space: Function })
DEBUG Resolving [105] = Load { pointer: [104] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [106] = Binary { op: Add, left: [105], right: [29] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [107] = Load { pointer: [35] } : Handle([1])
DEBUG Resolving [108] = Compose { ty: [2], components: [[107], [7]] } : Handle([2])
DEBUG Resolving [0] = FunctionArgument(0) : Handle([2])
DEBUG Resolving [1] = Literal(AbstractFloat(0.4122214708)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [2] = AccessIndex { base: [0], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [3] = Literal(F32(0.41222146)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [4] = Binary { op: Multiply, left: [3], right: [2] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [5] = Literal(AbstractFloat(0.5363325363)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [6] = AccessIndex { base: [0], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [7] = Literal(F32(0.53633255)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [8] = Binary { op: Multiply, left: [7], right: [6] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [9] = Binary { op: Add, left: [4], right: [8] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [10] = Literal(AbstractFloat(0.0514459929)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [11] = AccessIndex { base: [0], index: 2 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [12] = Literal(F32(0.051445995)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [13] = Binary { op: Multiply, left: [12], right: [11] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [14] = Binary { op: Add, left: [9], right: [13] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [15] = Literal(AbstractFloat(0.2119034982)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [16] = AccessIndex { base: [0], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [17] = Literal(F32(0.2119035)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [18] = Binary { op: Multiply, left: [17], right: [16] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [19] = Literal(AbstractFloat(0.6806995451)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [20] = AccessIndex { base: [0], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [21] = Literal(F32(0.6806995)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [22] = Binary { op: Multiply, left: [21], right: [20] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [23] = Binary { op: Add, left: [18], right: [22] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [24] = Literal(AbstractFloat(0.1073969566)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [25] = AccessIndex { base: [0], index: 2 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [26] = Literal(F32(0.10739696)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [27] = Binary { op: Multiply, left: [26], right: [25] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [28] = Binary { op: Add, left: [23], right: [27] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [29] = Literal(AbstractFloat(0.0883024619)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [30] = AccessIndex { base: [0], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [31] = Literal(F32(0.08830246)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [32] = Binary { op: Multiply, left: [31], right: [30] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [33] = Literal(AbstractFloat(0.2817188376)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [34] = AccessIndex { base: [0], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [35] = Literal(F32(0.28171885)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [36] = Binary { op: Multiply, left: [35], right: [34] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [37] = Binary { op: Add, left: [32], right: [36] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [38] = Literal(AbstractFloat(0.6299787005)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [39] = AccessIndex { base: [0], index: 2 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [40] = Literal(F32(0.6299787)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [41] = Binary { op: Multiply, left: [40], right: [39] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [42] = Binary { op: Add, left: [37], right: [41] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [43] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [44] = Literal(AbstractFloat(3.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, {AbstractFloat}
DEBUG consensus: {AbstractFloat}
DEBUG Resolving [45] = Literal(AbstractFloat(0.3333333333333333)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 1 of type {AbstractFloat}
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [46] = Literal(F32(0.33333334)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG initial overloads for Pow, List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [47] = Math { fun: Pow, arg: [14], arg1: Some([46]), arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [48] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [49] = Literal(AbstractFloat(3.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, {AbstractFloat}
DEBUG consensus: {AbstractFloat}
DEBUG Resolving [50] = Literal(AbstractFloat(0.3333333333333333)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 1 of type {AbstractFloat}
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [51] = Literal(F32(0.33333334)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG initial overloads for Pow, List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [52] = Math { fun: Pow, arg: [28], arg1: Some([51]), arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [53] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [54] = Literal(AbstractFloat(3.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, {AbstractFloat}
DEBUG consensus: {AbstractFloat}
DEBUG Resolving [55] = Literal(AbstractFloat(0.3333333333333333)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 1 of type {AbstractFloat}
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [56] = Literal(F32(0.33333334)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG initial overloads for Pow, List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [57] = Math { fun: Pow, arg: [42], arg1: Some([56]), arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [58] = Literal(AbstractFloat(0.2104542553)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [59] = Literal(F32(0.21045426)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [60] = Binary { op: Multiply, left: [59], right: [47] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [61] = Literal(AbstractFloat(0.793617785)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [62] = Literal(F32(0.7936178)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [63] = Binary { op: Multiply, left: [62], right: [52] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [64] = Binary { op: Add, left: [60], right: [63] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [65] = Literal(AbstractFloat(0.0040720468)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [66] = Literal(F32(0.004072047)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [67] = Binary { op: Multiply, left: [66], right: [57] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [68] = Binary { op: Subtract, left: [64], right: [67] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [69] = Literal(AbstractFloat(1.9779984951)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [70] = Literal(F32(1.9779985)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [71] = Binary { op: Multiply, left: [70], right: [47] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [72] = Literal(AbstractFloat(2.428592205)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [73] = Literal(F32(2.4285922)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [74] = Binary { op: Multiply, left: [73], right: [52] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [75] = Binary { op: Subtract, left: [71], right: [74] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [76] = Literal(AbstractFloat(0.4505937099)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [77] = Literal(F32(0.4505937)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [78] = Binary { op: Multiply, left: [77], right: [57] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [79] = Binary { op: Add, left: [75], right: [78] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [80] = Literal(AbstractFloat(0.0259040371)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [81] = Literal(F32(0.025904037)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [82] = Binary { op: Multiply, left: [81], right: [47] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [83] = Literal(AbstractFloat(0.7827717662)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [84] = Literal(F32(0.78277177)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [85] = Binary { op: Multiply, left: [84], right: [52] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [86] = Binary { op: Add, left: [82], right: [85] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [87] = Literal(AbstractFloat(0.808675766)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [88] = Literal(F32(0.80867577)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [89] = Binary { op: Multiply, left: [88], right: [57] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [90] = Binary { op: Subtract, left: [86], right: [89] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [91] = AccessIndex { base: [0], index: 3 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [92] = Compose { ty: [2], components: [[68], [79], [90], [91]] } : Handle([2])
DEBUG Resolving [0] = FunctionArgument(0) : Handle([2])
DEBUG Resolving [1] = AccessIndex { base: [0], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [2] = Literal(AbstractFloat(0.3963377774)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [3] = AccessIndex { base: [0], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [4] = Literal(F32(0.39633778)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [5] = Binary { op: Multiply, left: [4], right: [3] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [6] = Binary { op: Add, left: [1], right: [5] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [7] = Literal(AbstractFloat(0.2158037573)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [8] = AccessIndex { base: [0], index: 2 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [9] = Literal(F32(0.21580376)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [10] = Binary { op: Multiply, left: [9], right: [8] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [11] = Binary { op: Add, left: [6], right: [10] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [12] = AccessIndex { base: [0], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [13] = Literal(AbstractFloat(0.1055613458)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [14] = AccessIndex { base: [0], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [15] = Literal(F32(0.105561346)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [16] = Binary { op: Multiply, left: [15], right: [14] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [17] = Binary { op: Subtract, left: [12], right: [16] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [18] = Literal(AbstractFloat(0.0638541728)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [19] = AccessIndex { base: [0], index: 2 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [20] = Literal(F32(0.06385417)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [21] = Binary { op: Multiply, left: [20], right: [19] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [22] = Binary { op: Subtract, left: [17], right: [21] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [23] = AccessIndex { base: [0], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [24] = Literal(AbstractFloat(0.0894841775)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [25] = AccessIndex { base: [0], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [26] = Literal(F32(0.08948418)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [27] = Binary { op: Multiply, left: [26], right: [25] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [28] = Binary { op: Subtract, left: [23], right: [27] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [29] = Literal(AbstractFloat(1.291485548)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [30] = AccessIndex { base: [0], index: 2 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [31] = Literal(F32(1.2914855)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [32] = Binary { op: Multiply, left: [31], right: [30] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [33] = Binary { op: Subtract, left: [28], right: [32] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [34] = Binary { op: Multiply, left: [11], right: [11] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [35] = Binary { op: Multiply, left: [34], right: [11] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [36] = Binary { op: Multiply, left: [22], right: [22] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [37] = Binary { op: Multiply, left: [36], right: [22] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [38] = Binary { op: Multiply, left: [33], right: [33] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [39] = Binary { op: Multiply, left: [38], right: [33] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [40] = Literal(AbstractFloat(4.0767416621)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [41] = Literal(F32(4.0767417)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [42] = Binary { op: Multiply, left: [41], right: [35] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [43] = Literal(AbstractFloat(3.3077115913)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [44] = Literal(F32(3.3077116)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [45] = Binary { op: Multiply, left: [44], right: [37] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [46] = Binary { op: Subtract, left: [42], right: [45] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [47] = Literal(AbstractFloat(0.2309699292)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [48] = Literal(F32(0.23096994)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [49] = Binary { op: Multiply, left: [48], right: [39] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [50] = Binary { op: Add, left: [46], right: [49] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [51] = Literal(AbstractFloat(1.2684380046)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [52] = Literal(AbstractFloat(-1.2684380046)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [53] = Literal(F32(-1.268438)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [54] = Binary { op: Multiply, left: [53], right: [35] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [55] = Literal(AbstractFloat(2.6097574011)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [56] = Literal(F32(2.6097574)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [57] = Binary { op: Multiply, left: [56], right: [37] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [58] = Binary { op: Add, left: [54], right: [57] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [59] = Literal(AbstractFloat(0.3413193965)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [60] = Literal(F32(0.34131938)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [61] = Binary { op: Multiply, left: [60], right: [39] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [62] = Binary { op: Subtract, left: [58], right: [61] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [63] = Literal(AbstractFloat(0.0041960863)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [64] = Literal(AbstractFloat(-0.0041960863)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [65] = Literal(F32(-0.0041960864)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [66] = Binary { op: Multiply, left: [65], right: [35] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [67] = Literal(AbstractFloat(0.7034186147)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [68] = Literal(F32(0.7034186)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [69] = Binary { op: Multiply, left: [68], right: [37] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [70] = Binary { op: Subtract, left: [66], right: [69] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [71] = Literal(AbstractFloat(1.707614701)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [72] = Literal(F32(1.7076147)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [73] = Binary { op: Multiply, left: [72], right: [39] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [74] = Binary { op: Add, left: [70], right: [73] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [75] = AccessIndex { base: [0], index: 3 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [76] = Compose { ty: [2], components: [[50], [62], [74], [75]] } : Handle([2])
DEBUG Resolving [0] = FunctionArgument(0) : Handle([2])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([2])
DEBUG Resolving [2] = AccessIndex { base: [1], index: 3 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [3] = AccessIndex { base: [0], index: 3 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [4] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [5] = AccessIndex { base: [1], index: 3 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [6] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [7] = Binary { op: Subtract, left: [6], right: [5] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [8] = Binary { op: Multiply, left: [3], right: [7] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [9] = Binary { op: Add, left: [2], right: [8] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [10] = Swizzle { size: Tri, vector: [1], pattern: [X, Y, Z, X] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [11] = AccessIndex { base: [1], index: 3 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: vec3<f32>, f32
DEBUG consensus: f32
DEBUG Resolving [12] = Binary { op: Multiply, left: [10], right: [11] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [13] = Swizzle { size: Tri, vector: [0], pattern: [X, Y, Z, X] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [14] = AccessIndex { base: [0], index: 3 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: vec3<f32>, f32
DEBUG consensus: f32
DEBUG Resolving [15] = Binary { op: Multiply, left: [13], right: [14] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [16] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [17] = AccessIndex { base: [1], index: 3 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [18] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [19] = Binary { op: Subtract, left: [18], right: [17] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: vec3<f32>, f32
DEBUG consensus: f32
DEBUG Resolving [20] = Binary { op: Multiply, left: [15], right: [19] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec3<f32>, vec3<f32>
DEBUG consensus: f32
DEBUG Resolving [21] = Binary { op: Add, left: [12], right: [20] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [22] = Splat { size: Tri, value: [9] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec3<f32>, vec3<f32>
DEBUG consensus: f32
DEBUG Resolving [23] = Binary { op: Divide, left: [21], right: [22] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [24] = Compose { ty: [2], components: [[23], [9]] } : Handle([2])
DEBUG Resolving [0] = FunctionArgument(0) : Handle([0])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [2] = Binary { op: Multiply, left: [0], right: [0] } : Handle([0])
DEBUG Resolving [3] = Unary { op: Negate, expr: [2] } : Handle([0])
DEBUG Resolving [4] = Literal(AbstractFloat(2.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [5] = Literal(F32(2.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [6] = Binary { op: Multiply, left: [5], right: [1] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [7] = Binary { op: Multiply, left: [6], right: [1] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [8] = Binary { op: Divide, left: [3], right: [7] } : Handle([0])
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Exp, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [9] = Math { fun: Exp, arg: [8], arg1: None, arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [10] = Literal(AbstractFloat(2.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [11] = Constant([0]) : Handle([0])
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [12] = Literal(F32(2.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [13] = Literal(F32(3.1415925)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [14] = Literal(F32(6.283185)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [15] = Literal(F32(2.5066283)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [16] = Binary { op: Multiply, left: [15], right: [1] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [17] = Binary { op: Divide, left: [9], right: [16] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [0] = FunctionArgument(0) : Handle([3])
DEBUG Initial overloads: List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type vec2<f32>
DEBUG Remaining overloads: List {
rules: [
(vec2<f32>) -> vec2<f32>,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Sign, List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type vec2<f32>: List {
rules: [
(vec2<f32>) -> vec2<f32>,
],
conclude: ArgumentType,
}
DEBUG Resolving [1] = Math { fun: Sign, arg: [0], arg1: None, arg2: None, arg3: None } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Initial overloads: List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type vec2<f32>
DEBUG Remaining overloads: List {
rules: [
(vec2<f32>) -> vec2<f32>,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Abs, List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type vec2<f32>: List {
rules: [
(vec2<f32>) -> vec2<f32>,
],
conclude: ArgumentType,
}
DEBUG Resolving [2] = Math { fun: Abs, arg: [0], arg1: None, arg2: None, arg3: None } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [3] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [4] = Literal(AbstractFloat(0.278393)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [5] = Literal(AbstractFloat(0.230389)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [6] = Literal(AbstractFloat(0.000972)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [7] = Literal(AbstractFloat(0.078108)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [8] = Literal(F32(0.078108)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [9] = Binary { op: Multiply, left: [8], right: [2] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [10] = Splat { size: Bi, value: [6] } : Value(Vector { size: Bi, scalar: Scalar { kind: AbstractFloat, width: 8 } })
DEBUG wgsl automatic_conversion_consensus: vec2<{AbstractFloat}>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [11] = Literal(F32(0.000972)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [12] = Splat { size: Bi, value: [11] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [13] = Binary { op: Add, left: [12], right: [9] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [14] = Binary { op: Multiply, left: [13], right: [2] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [15] = Splat { size: Bi, value: [5] } : Value(Vector { size: Bi, scalar: Scalar { kind: AbstractFloat, width: 8 } })
DEBUG wgsl automatic_conversion_consensus: vec2<{AbstractFloat}>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [16] = Literal(F32(0.230389)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [17] = Splat { size: Bi, value: [16] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [18] = Binary { op: Add, left: [17], right: [14] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [19] = Binary { op: Multiply, left: [18], right: [2] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [20] = Splat { size: Bi, value: [4] } : Value(Vector { size: Bi, scalar: Scalar { kind: AbstractFloat, width: 8 } })
DEBUG wgsl automatic_conversion_consensus: vec2<{AbstractFloat}>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [21] = Literal(F32(0.278393)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [22] = Splat { size: Bi, value: [21] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [23] = Binary { op: Add, left: [22], right: [19] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [24] = Binary { op: Multiply, left: [23], right: [2] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [25] = Splat { size: Bi, value: [3] } : Value(Vector { size: Bi, scalar: Scalar { kind: AbstractFloat, width: 8 } })
DEBUG wgsl automatic_conversion_consensus: vec2<{AbstractFloat}>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [26] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [27] = Splat { size: Bi, value: [26] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [28] = Binary { op: Add, left: [27], right: [24] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [29] = Binary { op: Multiply, left: [28], right: [28] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [30] = Binary { op: Multiply, left: [29], right: [29] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [31] = Binary { op: Divide, left: [1], right: [30] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [32] = Binary { op: Subtract, left: [1], right: [31] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [0] = FunctionArgument(0) : Handle([0])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([0])
DEBUG Resolving [2] = FunctionArgument(2) : Handle([0])
DEBUG Resolving [3] = FunctionArgument(3) : Handle([0])
DEBUG Resolving [4] = FunctionArgument(4) : Handle([3])
DEBUG Resolving [5] = AccessIndex { base: [4], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Initial overloads: List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [6] = Binary { op: Subtract, left: [5], right: [3] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG initial overloads for Abs, List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [7] = Math { fun: Abs, arg: [1], arg1: None, arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [8] = Binary { op: Subtract, left: [6], right: [7] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [9] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Initial overloads: List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 1 of type {AbstractFloat}
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [10] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG initial overloads for Min, List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [11] = Math { fun: Min, arg: [8], arg1: Some([10]), arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [12] = AccessIndex { base: [4], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [13] = Binary { op: Subtract, left: [12], right: [3] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [14] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [15] = Binary { op: Multiply, left: [3], right: [3] } : Handle([0])
DEBUG Resolving [16] = Binary { op: Multiply, left: [11], right: [11] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [17] = Binary { op: Subtract, left: [15], right: [16] } : Handle([0])
DEBUG Initial overloads: List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type {AbstractFloat}
DEBUG Remaining overloads: List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 1 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [18] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG initial overloads for Max, List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [19] = Math { fun: Max, arg: [18], arg1: Some([17]), arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Sqrt, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [20] = Math { fun: Sqrt, arg: [19], arg1: None, arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [21] = Binary { op: Add, left: [13], right: [20] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [22] = Literal(AbstractFloat(0.5)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [23] = Literal(AbstractFloat(0.5)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [24] = Unary { op: Negate, expr: [21] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [25] = Compose { ty: [3], components: [[24], [21]] } : Handle([3])
DEBUG Resolving [26] = Splat { size: Bi, value: [0] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [27] = Binary { op: Add, left: [26], right: [25] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [28] = Literal(AbstractFloat(0.5)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type {AbstractFloat}
DEBUG Remaining overloads: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
],
conclude: ArgumentType,
}
DEBUG Resolving [29] = Literal(AbstractFloat(0.7071067811865476)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [30] = Literal(F32(0.70710677)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [31] = Binary { op: Divide, left: [30], right: [2] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, f32
DEBUG consensus: f32
DEBUG Resolving [32] = Binary { op: Multiply, left: [27], right: [31] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [33] = CallResult([22]) : Handle([3])
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [34] = Literal(F32(0.5)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [35] = Binary { op: Multiply, left: [34], right: [33] } : Handle([3])
DEBUG Resolving [36] = Splat { size: Bi, value: [22] } : Value(Vector { size: Bi, scalar: Scalar { kind: AbstractFloat, width: 8 } })
DEBUG wgsl automatic_conversion_consensus: vec2<{AbstractFloat}>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [37] = Literal(F32(0.5)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [38] = Splat { size: Bi, value: [37] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [39] = Binary { op: Add, left: [38], right: [35] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [40] = AccessIndex { base: [39], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [41] = AccessIndex { base: [39], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [42] = Binary { op: Subtract, left: [40], right: [41] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [0] = FunctionArgument(0) : Handle([3])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([9])
DEBUG Resolving [2] = AccessIndex { base: [0], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [3] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [4] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [5] = Binary { op: Less, left: [2], right: [4] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [6] = AccessIndex { base: [0], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [7] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [8] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [9] = Binary { op: Less, left: [6], right: [8] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [10] = AccessIndex { base: [1], index: 0 } : Handle([0])
DEBUG Resolving [11] = AccessIndex { base: [1], index: 3 } : Handle([0])
DEBUG Resolving [12] = AccessIndex { base: [0], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [13] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [14] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [15] = Binary { op: Less, left: [12], right: [14] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [16] = AccessIndex { base: [1], index: 1 } : Handle([0])
DEBUG Resolving [17] = AccessIndex { base: [1], index: 2 } : Handle([0])
DEBUG Resolving [0] = FunctionArgument(0) : Handle([3])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([0])
DEBUG Resolving [2] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [3] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [4] = Binary { op: Equal, left: [1], right: [3] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [5] = AccessIndex { base: [0], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [6] = AccessIndex { base: [0], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Initial overloads: List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 1 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Max, List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [7] = Math { fun: Max, arg: [5], arg1: Some([6]), arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [8] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [9] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [10] = Splat { size: Bi, value: [9] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Initial overloads: List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type vec2<f32>
DEBUG Remaining overloads: List {
rules: [
(vec2<f32>, vec2<f32>) -> vec2<f32>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 1 of type vec2<f32>
DEBUG Remaining overloads: List {
rules: [
(vec2<f32>, vec2<f32>) -> vec2<f32>,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Max, List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type vec2<f32>: List {
rules: [
(vec2<f32>, vec2<f32>) -> vec2<f32>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type vec2<f32>: List {
rules: [
(vec2<f32>, vec2<f32>) -> vec2<f32>,
],
conclude: ArgumentType,
}
DEBUG Resolving [11] = Math { fun: Max, arg: [10], arg1: Some([0]), arg2: None, arg3: None } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Initial overloads: List {
rules: [
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<f32>) -> f32,
(vec2<f16>) -> f16,
(vec2<f64>) -> f64,
(vec3<f32>) -> f32,
(vec3<f16>) -> f16,
(vec3<f64>) -> f64,
(vec4<f32>) -> f32,
(vec4<f16>) -> f16,
(vec4<f64>) -> f64,
],
conclude: Scalar,
}
DEBUG Supplying argument 0 of type vec2<f32>
DEBUG Remaining overloads: List {
rules: [
(vec2<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG initial overloads for Length, List {
rules: [
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<f32>) -> f32,
(vec2<f16>) -> f16,
(vec2<f64>) -> f64,
(vec3<f32>) -> f32,
(vec3<f16>) -> f16,
(vec3<f64>) -> f64,
(vec4<f32>) -> f32,
(vec4<f16>) -> f16,
(vec4<f64>) -> f64,
],
conclude: Scalar,
}
DEBUG overloads after arg 0 of type vec2<f32>: List {
rules: [
(vec2<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG Resolving [12] = Math { fun: Length, arg: [11], arg1: None, arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [13] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [14] = AccessIndex { base: [0], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [15] = AccessIndex { base: [0], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Initial overloads: List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 1 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Max, List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [16] = Math { fun: Max, arg: [14], arg1: Some([15]), arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Initial overloads: List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type {AbstractFloat}
DEBUG Remaining overloads: List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 1 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [17] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG initial overloads for Min, List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [18] = Math { fun: Min, arg: [17], arg1: Some([16]), arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [19] = Binary { op: Add, left: [12], right: [18] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [20] = Binary { op: Subtract, left: [19], right: [1] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [0] = FunctionArgument(0) : Handle([3])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([8])
DEBUG Resolving [2] = FunctionArgument(2) : Handle([9])
DEBUG Resolving [3] = AccessIndex { base: [1], index: 1 } : Handle([3])
DEBUG Resolving [4] = Literal(AbstractFloat(2.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [5] = Splat { size: Bi, value: [4] } : Value(Vector { size: Bi, scalar: Scalar { kind: AbstractFloat, width: 8 } })
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<{AbstractFloat}>
DEBUG consensus: f32
DEBUG Resolving [6] = Literal(F32(2.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [7] = Splat { size: Bi, value: [6] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [8] = Binary { op: Divide, left: [3], right: [7] } : Handle([3])
DEBUG Resolving [9] = AccessIndex { base: [1], index: 0 } : Handle([3])
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [10] = Binary { op: Add, left: [9], right: [8] } : Handle([3])
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [11] = Binary { op: Subtract, left: [0], right: [10] } : Handle([3])
DEBUG Resolving [12] = CallResult([24]) : Handle([0])
DEBUG Initial overloads: List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type vec2<f32>
DEBUG Remaining overloads: List {
rules: [
(vec2<f32>) -> vec2<f32>,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Abs, List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type vec2<f32>: List {
rules: [
(vec2<f32>) -> vec2<f32>,
],
conclude: ArgumentType,
}
DEBUG Resolving [13] = Math { fun: Abs, arg: [11], arg1: None, arg2: None, arg3: None } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [14] = Binary { op: Subtract, left: [13], right: [8] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [15] = Splat { size: Bi, value: [12] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [16] = Binary { op: Add, left: [14], right: [15] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [17] = CallResult([25]) : Handle([0])
DEBUG Resolving [0] = FunctionArgument(0) : Handle([2])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([0])
DEBUG Resolving [2] = AccessIndex { base: [0], index: 3 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [3] = Binary { op: Multiply, left: [2], right: [1] } : Handle([0])
DEBUG Resolving [4] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [5] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [6] = GlobalVariable([0]) : Value(Pointer { base: [5], space: Uniform })
DEBUG Resolving [7] = AccessIndex { base: [6], index: 1 } : Value(Pointer { base: [4], space: Uniform })
DEBUG Resolving [8] = Load { pointer: [7] } : Handle([4])
DEBUG Resolving [9] = Literal(U32(0)) : Value(Scalar(Scalar { kind: Uint, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: u32, u32
DEBUG consensus: u32
DEBUG Resolving [10] = Binary { op: NotEqual, left: [8], right: [9] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [11] = Select { condition: [10], accept: [3], reject: [5] } : Handle([0])
DEBUG Resolving [12] = Swizzle { size: Tri, vector: [0], pattern: [X, Y, Z, X] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec3<f32>, f32
DEBUG consensus: f32
DEBUG Resolving [13] = Binary { op: Multiply, left: [12], right: [11] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [14] = Compose { ty: [2], components: [[13], [3]] } : Handle([2])
DEBUG Resolving [10] = Literal(I32(2)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [11] = Literal(AbstractInt(2)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [0] = FunctionArgument(0) : Handle([4])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([4])
DEBUG Resolving [2] = FunctionArgument(2) : Handle([11])
DEBUG Resolving [3] = FunctionArgument(3) : Handle([13])
DEBUG Resolving [4] = ZeroValue([24]) : Handle([24])
DEBUG Resolving [5] = LocalVariable([0]) : Value(Pointer { base: [24], space: Function })
DEBUG Resolving [6] = Literal(U32(0)) : Value(Scalar(Scalar { kind: Uint, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: u32, u32
DEBUG consensus: u32
DEBUG Resolving [7] = Binary { op: Equal, left: [0], right: [6] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [8] = Literal(U32(2)) : Value(Scalar(Scalar { kind: Uint, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: u32, u32
DEBUG consensus: u32
DEBUG Resolving [9] = Binary { op: Equal, left: [0], right: [8] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG wgsl automatic_conversion_consensus: bool, bool
DEBUG consensus: bool
DEBUG Resolving [10] = Binary { op: LogicalOr, left: [7], right: [9] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [11] = AccessIndex { base: [5], index: 0 } : Value(Pointer { base: [2], space: Function })
DEBUG Resolving [12] = CallResult([17]) : Handle([2])
DEBUG Resolving [13] = Literal(U32(1)) : Value(Scalar(Scalar { kind: Uint, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: u32, u32
DEBUG consensus: u32
DEBUG Resolving [14] = Binary { op: Equal, left: [0], right: [13] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [15] = AccessIndex { base: [5], index: 1 } : Value(Pointer { base: [2], space: Function })
DEBUG Resolving [16] = Literal(AbstractInt(0)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [17] = Literal(I32(0)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [18] = AccessIndex { base: [3], index: 0 } : Handle([12])
DEBUG Resolving [19] = AccessIndex { base: [18], index: 0 } : Handle([11])
DEBUG Resolving [20] = CallResult([17]) : Handle([2])
DEBUG Resolving [21] = AccessIndex { base: [5], index: 2 } : Value(Pointer { base: [2], space: Function })
DEBUG Resolving [22] = Literal(AbstractInt(1)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [23] = Literal(I32(1)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [24] = AccessIndex { base: [3], index: 1 } : Handle([12])
DEBUG Resolving [25] = AccessIndex { base: [24], index: 0 } : Handle([11])
DEBUG Resolving [26] = CallResult([17]) : Handle([2])
DEBUG Resolving [27] = Literal(U32(0)) : Value(Scalar(Scalar { kind: Uint, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: u32, u32
DEBUG consensus: u32
DEBUG Resolving [28] = Binary { op: Equal, left: [1], right: [27] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [29] = AccessIndex { base: [5], index: 1 } : Value(Pointer { base: [2], space: Function })
DEBUG Resolving [30] = AccessIndex { base: [5], index: 1 } : Value(Pointer { base: [2], space: Function })
DEBUG Resolving [31] = Load { pointer: [30] } : Handle([2])
DEBUG Resolving [32] = CallResult([15]) : Handle([2])
DEBUG Resolving [33] = AccessIndex { base: [5], index: 2 } : Value(Pointer { base: [2], space: Function })
DEBUG Resolving [34] = AccessIndex { base: [5], index: 2 } : Value(Pointer { base: [2], space: Function })
DEBUG Resolving [35] = Load { pointer: [34] } : Handle([2])
DEBUG Resolving [36] = CallResult([15]) : Handle([2])
DEBUG Resolving [37] = Literal(U32(1)) : Value(Scalar(Scalar { kind: Uint, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: u32, u32
DEBUG consensus: u32
DEBUG Resolving [38] = Binary { op: Equal, left: [1], right: [37] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [39] = AccessIndex { base: [5], index: 1 } : Value(Pointer { base: [2], space: Function })
DEBUG Resolving [40] = AccessIndex { base: [5], index: 1 } : Value(Pointer { base: [2], space: Function })
DEBUG Resolving [41] = Load { pointer: [40] } : Handle([2])
DEBUG Resolving [42] = CallResult([18]) : Handle([2])
DEBUG Resolving [43] = AccessIndex { base: [5], index: 2 } : Value(Pointer { base: [2], space: Function })
DEBUG Resolving [44] = AccessIndex { base: [5], index: 2 } : Value(Pointer { base: [2], space: Function })
DEBUG Resolving [45] = Load { pointer: [44] } : Handle([2])
DEBUG Resolving [46] = CallResult([18]) : Handle([2])
DEBUG Resolving [47] = Load { pointer: [5] } : Handle([24])
DEBUG Resolving [0] = FunctionArgument(0) : Handle([14])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([3])
DEBUG Resolving [2] = FunctionArgument(2) : Handle([8])
DEBUG Resolving [3] = FunctionArgument(3) : Handle([2])
DEBUG Resolving [4] = FunctionArgument(4) : Handle([2])
DEBUG Resolving [5] = FunctionArgument(5) : Handle([2])
DEBUG Resolving [6] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [7] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [8] = Splat { size: Quad, value: [7] } : Value(Vector { size: Quad, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [9] = LocalVariable([0]) : Value(Pointer { base: [2], space: Function })
DEBUG Resolving [10] = AccessIndex { base: [0], index: 0 } : Handle([4])
DEBUG Resolving [11] = Literal(U32(1)) : Value(Scalar(Scalar { kind: Uint, width: 4 }))
DEBUG Resolving [12] = Literal(U32(2)) : Value(Scalar(Scalar { kind: Uint, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: u32, u32, u32
DEBUG consensus: u32
DEBUG Resolving [13] = AccessIndex { base: [0], index: 3 } : Handle([0])
DEBUG Resolving [14] = Literal(AbstractFloat(360.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [15] = Literal(F32(360.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [16] = Binary { op: Modulo, left: [13], right: [15] } : Handle([0])
DEBUG Resolving [17] = Literal(AbstractFloat(90.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [18] = Literal(F32(90.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [19] = Binary { op: Subtract, left: [16], right: [18] } : Handle([0])
DEBUG Resolving [20] = Constant([0]) : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [21] = Binary { op: Multiply, left: [19], right: [20] } : Handle([0])
DEBUG Resolving [22] = Literal(AbstractFloat(180.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [23] = Literal(F32(180.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [24] = Binary { op: Divide, left: [21], right: [23] } : Handle([0])
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Cos, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [25] = Math { fun: Cos, arg: [24], arg1: None, arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG initial overloads for Sin, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [26] = Math { fun: Sin, arg: [24], arg1: None, arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [27] = Compose { ty: [3], components: [[25], [26]] } : Handle([3])
DEBUG Resolving [28] = LocalVariable([1]) : Value(Pointer { base: [3], space: Function })
DEBUG Resolving [29] = AccessIndex { base: [0], index: 4 } : Handle([13])
DEBUG Resolving [30] = Literal(AbstractInt(0)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [31] = Literal(I32(0)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [32] = AccessIndex { base: [29], index: 0 } : Handle([12])
DEBUG Resolving [33] = AccessIndex { base: [32], index: 1 } : Handle([0])
DEBUG Resolving [34] = AccessIndex { base: [0], index: 4 } : Handle([13])
DEBUG Resolving [35] = Literal(AbstractInt(1)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [36] = Literal(I32(1)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [37] = AccessIndex { base: [34], index: 1 } : Handle([12])
DEBUG Resolving [38] = AccessIndex { base: [37], index: 1 } : Handle([0])
DEBUG Resolving [39] = AccessIndex { base: [2], index: 1 } : Handle([3])
DEBUG Resolving [40] = AccessIndex { base: [39], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [41] = AccessIndex { base: [2], index: 1 } : Handle([3])
DEBUG Resolving [42] = AccessIndex { base: [41], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [43] = Binary { op: Greater, left: [40], right: [42] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [44] = AccessIndex { base: [28], index: 1 } : Value(ValuePointer { size: None, scalar: Scalar { kind: Float, width: 4 }, space: Function })
DEBUG Resolving [45] = AccessIndex { base: [2], index: 1 } : Handle([3])
DEBUG Resolving [46] = AccessIndex { base: [45], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [47] = AccessIndex { base: [2], index: 1 } : Handle([3])
DEBUG Resolving [48] = AccessIndex { base: [47], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [49] = Binary { op: Divide, left: [46], right: [48] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [50] = Load { pointer: [44] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [51] = Binary { op: Multiply, left: [50], right: [49] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [52] = AccessIndex { base: [28], index: 0 } : Value(ValuePointer { size: None, scalar: Scalar { kind: Float, width: 4 }, space: Function })
DEBUG Resolving [53] = AccessIndex { base: [2], index: 1 } : Handle([3])
DEBUG Resolving [54] = AccessIndex { base: [53], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [55] = AccessIndex { base: [2], index: 1 } : Handle([3])
DEBUG Resolving [56] = AccessIndex { base: [55], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [57] = Binary { op: Divide, left: [54], right: [56] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [58] = Load { pointer: [52] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [59] = Binary { op: Multiply, left: [58], right: [57] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [60] = AccessIndex { base: [2], index: 1 } : Handle([3])
DEBUG Resolving [61] = Literal(AbstractFloat(2.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [62] = Splat { size: Bi, value: [61] } : Value(Vector { size: Bi, scalar: Scalar { kind: AbstractFloat, width: 8 } })
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<{AbstractFloat}>
DEBUG consensus: f32
DEBUG Resolving [63] = Literal(F32(2.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [64] = Splat { size: Bi, value: [63] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [65] = Binary { op: Divide, left: [60], right: [64] } : Handle([3])
DEBUG Resolving [66] = AccessIndex { base: [2], index: 0 } : Handle([3])
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [67] = Binary { op: Add, left: [66], right: [65] } : Handle([3])
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [68] = Binary { op: Subtract, left: [1], right: [67] } : Handle([3])
DEBUG Resolving [69] = Load { pointer: [28] } : Handle([3])
DEBUG Initial overloads: List {
rules: [
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> {AbstractInt},
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> {AbstractFloat},
(vec2<i32>, vec2<i32>) -> i32,
(vec2<i64>, vec2<i64>) -> i64,
(vec2<u32>, vec2<u32>) -> u32,
(vec2<u64>, vec2<u64>) -> u64,
(vec2<f32>, vec2<f32>) -> f32,
(vec2<f16>, vec2<f16>) -> f16,
(vec2<f64>, vec2<f64>) -> f64,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> {AbstractInt},
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> {AbstractFloat},
(vec3<i32>, vec3<i32>) -> i32,
(vec3<i64>, vec3<i64>) -> i64,
(vec3<u32>, vec3<u32>) -> u32,
(vec3<u64>, vec3<u64>) -> u64,
(vec3<f32>, vec3<f32>) -> f32,
(vec3<f16>, vec3<f16>) -> f16,
(vec3<f64>, vec3<f64>) -> f64,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> {AbstractInt},
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> {AbstractFloat},
(vec4<i32>, vec4<i32>) -> i32,
(vec4<i64>, vec4<i64>) -> i64,
(vec4<u32>, vec4<u32>) -> u32,
(vec4<u64>, vec4<u64>) -> u64,
(vec4<f32>, vec4<f32>) -> f32,
(vec4<f16>, vec4<f16>) -> f16,
(vec4<f64>, vec4<f64>) -> f64,
],
conclude: Scalar,
}
DEBUG Supplying argument 0 of type vec2<f32>
DEBUG Remaining overloads: List {
rules: [
(vec2<f32>, vec2<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG Supplying argument 1 of type vec2<f32>
DEBUG Remaining overloads: List {
rules: [
(vec2<f32>, vec2<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG initial overloads for Dot, List {
rules: [
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> {AbstractInt},
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> {AbstractFloat},
(vec2<i32>, vec2<i32>) -> i32,
(vec2<i64>, vec2<i64>) -> i64,
(vec2<u32>, vec2<u32>) -> u32,
(vec2<u64>, vec2<u64>) -> u64,
(vec2<f32>, vec2<f32>) -> f32,
(vec2<f16>, vec2<f16>) -> f16,
(vec2<f64>, vec2<f64>) -> f64,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> {AbstractInt},
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> {AbstractFloat},
(vec3<i32>, vec3<i32>) -> i32,
(vec3<i64>, vec3<i64>) -> i64,
(vec3<u32>, vec3<u32>) -> u32,
(vec3<u64>, vec3<u64>) -> u64,
(vec3<f32>, vec3<f32>) -> f32,
(vec3<f16>, vec3<f16>) -> f16,
(vec3<f64>, vec3<f64>) -> f64,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> {AbstractInt},
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> {AbstractFloat},
(vec4<i32>, vec4<i32>) -> i32,
(vec4<i64>, vec4<i64>) -> i64,
(vec4<u32>, vec4<u32>) -> u32,
(vec4<u64>, vec4<u64>) -> u64,
(vec4<f32>, vec4<f32>) -> f32,
(vec4<f16>, vec4<f16>) -> f16,
(vec4<f64>, vec4<f64>) -> f64,
],
conclude: Scalar,
}
DEBUG overloads after arg 0 of type vec2<f32>: List {
rules: [
(vec2<f32>, vec2<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG overloads after arg 1 of type vec2<f32>: List {
rules: [
(vec2<f32>, vec2<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG Resolving [70] = Math { fun: Dot, arg: [68], arg1: Some([69]), arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [71] = Load { pointer: [28] } : Handle([3])
DEBUG Initial overloads: List {
rules: [
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<f32>) -> f32,
(vec2<f16>) -> f16,
(vec2<f64>) -> f64,
(vec3<f32>) -> f32,
(vec3<f16>) -> f16,
(vec3<f64>) -> f64,
(vec4<f32>) -> f32,
(vec4<f16>) -> f16,
(vec4<f64>) -> f64,
],
conclude: Scalar,
}
DEBUG Supplying argument 0 of type vec2<f32>
DEBUG Remaining overloads: List {
rules: [
(vec2<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG initial overloads for Length, List {
rules: [
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<f32>) -> f32,
(vec2<f16>) -> f16,
(vec2<f64>) -> f64,
(vec3<f32>) -> f32,
(vec3<f16>) -> f16,
(vec3<f64>) -> f64,
(vec4<f32>) -> f32,
(vec4<f16>) -> f16,
(vec4<f64>) -> f64,
],
conclude: Scalar,
}
DEBUG overloads after arg 0 of type vec2<f32>: List {
rules: [
(vec2<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG Resolving [72] = Math { fun: Length, arg: [71], arg1: None, arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [73] = Binary { op: Divide, left: [70], right: [72] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [74] = LocalVariable([2]) : Value(Pointer { base: [0], space: Function })
DEBUG Resolving [75] = AccessIndex { base: [28], index: 0 } : Value(ValuePointer { size: None, scalar: Scalar { kind: Float, width: 4 }, space: Function })
DEBUG Resolving [76] = Load { pointer: [75] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Initial overloads: List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Abs, List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [77] = Math { fun: Abs, arg: [76], arg1: None, arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [78] = AccessIndex { base: [28], index: 1 } : Value(ValuePointer { size: None, scalar: Scalar { kind: Float, width: 4 }, space: Function })
DEBUG Resolving [79] = Load { pointer: [78] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Initial overloads: List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Abs, List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [80] = Math { fun: Abs, arg: [79], arg1: None, arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [81] = Binary { op: Greater, left: [77], right: [80] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [82] = Load { pointer: [74] } : Handle([0])
DEBUG Resolving [83] = AccessIndex { base: [65], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [84] = Binary { op: Add, left: [82], right: [83] } : Handle([0])
DEBUG Resolving [85] = AccessIndex { base: [2], index: 1 } : Handle([3])
DEBUG Resolving [86] = AccessIndex { base: [85], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [87] = Binary { op: Divide, left: [84], right: [86] } : Handle([0])
DEBUG Resolving [88] = Load { pointer: [74] } : Handle([0])
DEBUG Resolving [89] = AccessIndex { base: [65], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [90] = Binary { op: Add, left: [88], right: [89] } : Handle([0])
DEBUG Resolving [91] = AccessIndex { base: [2], index: 1 } : Handle([3])
DEBUG Resolving [92] = AccessIndex { base: [91], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [93] = Binary { op: Divide, left: [90], right: [92] } : Handle([0])
DEBUG Resolving [94] = Load { pointer: [74] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [95] = Binary { op: Subtract, left: [94], right: [33] } : Handle([0])
DEBUG Resolving [96] = Binary { op: Subtract, left: [38], right: [33] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [97] = Binary { op: Divide, left: [95], right: [96] } : Handle([0])
DEBUG Resolving [98] = Load { pointer: [74] } : Handle([0])
DEBUG Resolving [99] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [100] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Initial overloads: List {
rules: [
({AbstractInt}, {AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32, i32) -> i32,
(i64, i64, i64) -> i64,
(u32, u32, u32) -> u32,
(u64, u64, u64) -> u64,
(f32, f32, f32) -> f32,
(f16, f16, f16) -> f16,
(f64, f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 1 of type {AbstractFloat}
DEBUG Remaining overloads: List {
rules: [
(f32, f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 2 of type {AbstractFloat}
DEBUG Remaining overloads: List {
rules: [
(f32, f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [101] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [102] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG initial overloads for Clamp, List {
rules: [
({AbstractInt}, {AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32, i32) -> i32,
(i64, i64, i64) -> i64,
(u32, u32, u32) -> u32,
(u64, u64, u64) -> u64,
(f32, f32, f32) -> f32,
(f16, f16, f16) -> f16,
(f64, f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [103] = Math { fun: Clamp, arg: [98], arg1: Some([101]), arg2: Some([102]), arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [104] = AccessIndex { base: [0], index: 1 } : Handle([4])
DEBUG Resolving [105] = Literal(U32(1)) : Value(Scalar(Scalar { kind: Uint, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: u32, u32
DEBUG consensus: u32
DEBUG Resolving [106] = Load { pointer: [74] } : Handle([0])
DEBUG Initial overloads: [
({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, {AbstractFloat}) -> vec2<{AbstractFloat}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, {AbstractFloat}) -> vec3<{AbstractFloat}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, {AbstractFloat}) -> vec4<{AbstractFloat}>,
(f32, f32, f32) -> f32,
(f32, f32, f32) -> f32,
(vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f32>, vec2<f32>, f32) -> vec2<f32>,
(vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f32>, vec3<f32>, f32) -> vec3<f32>,
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
(f16, f16, f16) -> f16,
(f16, f16, f16) -> f16,
(vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f16>, vec2<f16>, f16) -> vec2<f16>,
(vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f16>, vec3<f16>, f16) -> vec3<f16>,
(vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f16>, vec4<f16>, f16) -> vec4<f16>,
(f64, f64, f64) -> f64,
(f64, f64, f64) -> f64,
(vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec2<f64>, vec2<f64>, f64) -> vec2<f64>,
(vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec3<f64>, vec3<f64>, f64) -> vec3<f64>,
(vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64>,
(vec4<f64>, vec4<f64>, f64) -> vec4<f64>,
]
DEBUG Supplying argument 0 of type vec4<f32>
DEBUG arg 0 of type vec4<f32>
DEBUG considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat}
DEBUG no conversion possible
DEBUG considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat}
DEBUG no conversion possible
DEBUG considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, {AbstractFloat}) -> vec2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, {AbstractFloat}) -> vec3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, {AbstractFloat}) -> vec4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (f32, f32, f32) -> f32
DEBUG no conversion possible
DEBUG considering rule (f32, f32, f32) -> f32
DEBUG no conversion possible
DEBUG considering rule (vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32>
DEBUG no conversion possible
DEBUG considering rule (vec2<f32>, vec2<f32>, f32) -> vec2<f32>
DEBUG no conversion possible
DEBUG considering rule (vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32>
DEBUG no conversion possible
DEBUG considering rule (vec3<f32>, vec3<f32>, f32) -> vec3<f32>
DEBUG no conversion possible
DEBUG considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>
DEBUG types are equivalent
DEBUG considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32>
DEBUG types are equivalent
DEBUG considering rule (f16, f16, f16) -> f16
DEBUG no conversion possible
DEBUG considering rule (f16, f16, f16) -> f16
DEBUG no conversion possible
DEBUG considering rule (vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16>
DEBUG no conversion possible
DEBUG considering rule (vec2<f16>, vec2<f16>, f16) -> vec2<f16>
DEBUG no conversion possible
DEBUG considering rule (vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16>
DEBUG no conversion possible
DEBUG considering rule (vec3<f16>, vec3<f16>, f16) -> vec3<f16>
DEBUG no conversion possible
DEBUG considering rule (vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16>
DEBUG no conversion possible
DEBUG considering rule (vec4<f16>, vec4<f16>, f16) -> vec4<f16>
DEBUG no conversion possible
DEBUG considering rule (f64, f64, f64) -> f64
DEBUG no conversion possible
DEBUG considering rule (f64, f64, f64) -> f64
DEBUG no conversion possible
DEBUG considering rule (vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64>
DEBUG no conversion possible
DEBUG considering rule (vec2<f64>, vec2<f64>, f64) -> vec2<f64>
DEBUG no conversion possible
DEBUG considering rule (vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64>
DEBUG no conversion possible
DEBUG considering rule (vec3<f64>, vec3<f64>, f64) -> vec3<f64>
DEBUG no conversion possible
DEBUG considering rule (vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64>
DEBUG no conversion possible
DEBUG considering rule (vec4<f64>, vec4<f64>, f64) -> vec4<f64>
DEBUG no conversion possible
DEBUG Remaining overloads: [
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
]
DEBUG Supplying argument 1 of type vec4<f32>
DEBUG arg 1 of type vec4<f32>
DEBUG considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>
DEBUG types are equivalent
DEBUG considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32>
DEBUG types are equivalent
DEBUG Remaining overloads: [
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
]
DEBUG Supplying argument 2 of type f32
DEBUG arg 2 of type f32
DEBUG considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>
DEBUG no conversion possible
DEBUG considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32>
DEBUG types are equivalent
DEBUG Remaining overloads: [
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
]
DEBUG initial overloads for Mix, [
({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, {AbstractFloat}) -> vec2<{AbstractFloat}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, {AbstractFloat}) -> vec3<{AbstractFloat}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, {AbstractFloat}) -> vec4<{AbstractFloat}>,
(f32, f32, f32) -> f32,
(f32, f32, f32) -> f32,
(vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f32>, vec2<f32>, f32) -> vec2<f32>,
(vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f32>, vec3<f32>, f32) -> vec3<f32>,
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
(f16, f16, f16) -> f16,
(f16, f16, f16) -> f16,
(vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f16>, vec2<f16>, f16) -> vec2<f16>,
(vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f16>, vec3<f16>, f16) -> vec3<f16>,
(vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f16>, vec4<f16>, f16) -> vec4<f16>,
(f64, f64, f64) -> f64,
(f64, f64, f64) -> f64,
(vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec2<f64>, vec2<f64>, f64) -> vec2<f64>,
(vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec3<f64>, vec3<f64>, f64) -> vec3<f64>,
(vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64>,
(vec4<f64>, vec4<f64>, f64) -> vec4<f64>,
]
DEBUG arg 0 of type vec4<f32>
DEBUG considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat}
DEBUG no conversion possible
DEBUG considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat}
DEBUG no conversion possible
DEBUG considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, {AbstractFloat}) -> vec2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, {AbstractFloat}) -> vec3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, {AbstractFloat}) -> vec4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (f32, f32, f32) -> f32
DEBUG no conversion possible
DEBUG considering rule (f32, f32, f32) -> f32
DEBUG no conversion possible
DEBUG considering rule (vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32>
DEBUG no conversion possible
DEBUG considering rule (vec2<f32>, vec2<f32>, f32) -> vec2<f32>
DEBUG no conversion possible
DEBUG considering rule (vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32>
DEBUG no conversion possible
DEBUG considering rule (vec3<f32>, vec3<f32>, f32) -> vec3<f32>
DEBUG no conversion possible
DEBUG considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>
DEBUG types are equivalent
DEBUG considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32>
DEBUG types are equivalent
DEBUG considering rule (f16, f16, f16) -> f16
DEBUG no conversion possible
DEBUG considering rule (f16, f16, f16) -> f16
DEBUG no conversion possible
DEBUG considering rule (vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16>
DEBUG no conversion possible
DEBUG considering rule (vec2<f16>, vec2<f16>, f16) -> vec2<f16>
DEBUG no conversion possible
DEBUG considering rule (vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16>
DEBUG no conversion possible
DEBUG considering rule (vec3<f16>, vec3<f16>, f16) -> vec3<f16>
DEBUG no conversion possible
DEBUG considering rule (vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16>
DEBUG no conversion possible
DEBUG considering rule (vec4<f16>, vec4<f16>, f16) -> vec4<f16>
DEBUG no conversion possible
DEBUG considering rule (f64, f64, f64) -> f64
DEBUG no conversion possible
DEBUG considering rule (f64, f64, f64) -> f64
DEBUG no conversion possible
DEBUG considering rule (vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64>
DEBUG no conversion possible
DEBUG considering rule (vec2<f64>, vec2<f64>, f64) -> vec2<f64>
DEBUG no conversion possible
DEBUG considering rule (vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64>
DEBUG no conversion possible
DEBUG considering rule (vec3<f64>, vec3<f64>, f64) -> vec3<f64>
DEBUG no conversion possible
DEBUG considering rule (vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64>
DEBUG no conversion possible
DEBUG considering rule (vec4<f64>, vec4<f64>, f64) -> vec4<f64>
DEBUG no conversion possible
DEBUG overloads after arg 0 of type vec4<f32>: [
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
]
DEBUG arg 1 of type vec4<f32>
DEBUG considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>
DEBUG types are equivalent
DEBUG considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32>
DEBUG types are equivalent
DEBUG overloads after arg 1 of type vec4<f32>: [
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
]
DEBUG Resolving [107] = Math { fun: Mix, arg: [4], arg1: Some([5]), arg2: Some([106]), arg3: None } : Value(Vector { size: Quad, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [108] = CallResult([16]) : Handle([2])
DEBUG Resolving [109] = Load { pointer: [74] } : Handle([0])
DEBUG Initial overloads: [
({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, {AbstractFloat}) -> vec2<{AbstractFloat}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, {AbstractFloat}) -> vec3<{AbstractFloat}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, {AbstractFloat}) -> vec4<{AbstractFloat}>,
(f32, f32, f32) -> f32,
(f32, f32, f32) -> f32,
(vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f32>, vec2<f32>, f32) -> vec2<f32>,
(vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f32>, vec3<f32>, f32) -> vec3<f32>,
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
(f16, f16, f16) -> f16,
(f16, f16, f16) -> f16,
(vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f16>, vec2<f16>, f16) -> vec2<f16>,
(vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f16>, vec3<f16>, f16) -> vec3<f16>,
(vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f16>, vec4<f16>, f16) -> vec4<f16>,
(f64, f64, f64) -> f64,
(f64, f64, f64) -> f64,
(vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec2<f64>, vec2<f64>, f64) -> vec2<f64>,
(vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec3<f64>, vec3<f64>, f64) -> vec3<f64>,
(vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64>,
(vec4<f64>, vec4<f64>, f64) -> vec4<f64>,
]
DEBUG Supplying argument 0 of type vec4<f32>
DEBUG arg 0 of type vec4<f32>
DEBUG considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat}
DEBUG no conversion possible
DEBUG considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat}
DEBUG no conversion possible
DEBUG considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, {AbstractFloat}) -> vec2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, {AbstractFloat}) -> vec3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, {AbstractFloat}) -> vec4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (f32, f32, f32) -> f32
DEBUG no conversion possible
DEBUG considering rule (f32, f32, f32) -> f32
DEBUG no conversion possible
DEBUG considering rule (vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32>
DEBUG no conversion possible
DEBUG considering rule (vec2<f32>, vec2<f32>, f32) -> vec2<f32>
DEBUG no conversion possible
DEBUG considering rule (vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32>
DEBUG no conversion possible
DEBUG considering rule (vec3<f32>, vec3<f32>, f32) -> vec3<f32>
DEBUG no conversion possible
DEBUG considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>
DEBUG types are equivalent
DEBUG considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32>
DEBUG types are equivalent
DEBUG considering rule (f16, f16, f16) -> f16
DEBUG no conversion possible
DEBUG considering rule (f16, f16, f16) -> f16
DEBUG no conversion possible
DEBUG considering rule (vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16>
DEBUG no conversion possible
DEBUG considering rule (vec2<f16>, vec2<f16>, f16) -> vec2<f16>
DEBUG no conversion possible
DEBUG considering rule (vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16>
DEBUG no conversion possible
DEBUG considering rule (vec3<f16>, vec3<f16>, f16) -> vec3<f16>
DEBUG no conversion possible
DEBUG considering rule (vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16>
DEBUG no conversion possible
DEBUG considering rule (vec4<f16>, vec4<f16>, f16) -> vec4<f16>
DEBUG no conversion possible
DEBUG considering rule (f64, f64, f64) -> f64
DEBUG no conversion possible
DEBUG considering rule (f64, f64, f64) -> f64
DEBUG no conversion possible
DEBUG considering rule (vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64>
DEBUG no conversion possible
DEBUG considering rule (vec2<f64>, vec2<f64>, f64) -> vec2<f64>
DEBUG no conversion possible
DEBUG considering rule (vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64>
DEBUG no conversion possible
DEBUG considering rule (vec3<f64>, vec3<f64>, f64) -> vec3<f64>
DEBUG no conversion possible
DEBUG considering rule (vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64>
DEBUG no conversion possible
DEBUG considering rule (vec4<f64>, vec4<f64>, f64) -> vec4<f64>
DEBUG no conversion possible
DEBUG Remaining overloads: [
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
]
DEBUG Supplying argument 1 of type vec4<f32>
DEBUG arg 1 of type vec4<f32>
DEBUG considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>
DEBUG types are equivalent
DEBUG considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32>
DEBUG types are equivalent
DEBUG Remaining overloads: [
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
]
DEBUG Supplying argument 2 of type f32
DEBUG arg 2 of type f32
DEBUG considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>
DEBUG no conversion possible
DEBUG considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32>
DEBUG types are equivalent
DEBUG Remaining overloads: [
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
]
DEBUG initial overloads for Mix, [
({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, {AbstractFloat}) -> vec2<{AbstractFloat}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, {AbstractFloat}) -> vec3<{AbstractFloat}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, {AbstractFloat}) -> vec4<{AbstractFloat}>,
(f32, f32, f32) -> f32,
(f32, f32, f32) -> f32,
(vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f32>, vec2<f32>, f32) -> vec2<f32>,
(vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f32>, vec3<f32>, f32) -> vec3<f32>,
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
(f16, f16, f16) -> f16,
(f16, f16, f16) -> f16,
(vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f16>, vec2<f16>, f16) -> vec2<f16>,
(vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f16>, vec3<f16>, f16) -> vec3<f16>,
(vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f16>, vec4<f16>, f16) -> vec4<f16>,
(f64, f64, f64) -> f64,
(f64, f64, f64) -> f64,
(vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec2<f64>, vec2<f64>, f64) -> vec2<f64>,
(vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec3<f64>, vec3<f64>, f64) -> vec3<f64>,
(vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64>,
(vec4<f64>, vec4<f64>, f64) -> vec4<f64>,
]
DEBUG arg 0 of type vec4<f32>
DEBUG considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat}
DEBUG no conversion possible
DEBUG considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat}
DEBUG no conversion possible
DEBUG considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, {AbstractFloat}) -> vec2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, {AbstractFloat}) -> vec3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, {AbstractFloat}) -> vec4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (f32, f32, f32) -> f32
DEBUG no conversion possible
DEBUG considering rule (f32, f32, f32) -> f32
DEBUG no conversion possible
DEBUG considering rule (vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32>
DEBUG no conversion possible
DEBUG considering rule (vec2<f32>, vec2<f32>, f32) -> vec2<f32>
DEBUG no conversion possible
DEBUG considering rule (vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32>
DEBUG no conversion possible
DEBUG considering rule (vec3<f32>, vec3<f32>, f32) -> vec3<f32>
DEBUG no conversion possible
DEBUG considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>
DEBUG types are equivalent
DEBUG considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32>
DEBUG types are equivalent
DEBUG considering rule (f16, f16, f16) -> f16
DEBUG no conversion possible
DEBUG considering rule (f16, f16, f16) -> f16
DEBUG no conversion possible
DEBUG considering rule (vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16>
DEBUG no conversion possible
DEBUG considering rule (vec2<f16>, vec2<f16>, f16) -> vec2<f16>
DEBUG no conversion possible
DEBUG considering rule (vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16>
DEBUG no conversion possible
DEBUG considering rule (vec3<f16>, vec3<f16>, f16) -> vec3<f16>
DEBUG no conversion possible
DEBUG considering rule (vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16>
DEBUG no conversion possible
DEBUG considering rule (vec4<f16>, vec4<f16>, f16) -> vec4<f16>
DEBUG no conversion possible
DEBUG considering rule (f64, f64, f64) -> f64
DEBUG no conversion possible
DEBUG considering rule (f64, f64, f64) -> f64
DEBUG no conversion possible
DEBUG considering rule (vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64>
DEBUG no conversion possible
DEBUG considering rule (vec2<f64>, vec2<f64>, f64) -> vec2<f64>
DEBUG no conversion possible
DEBUG considering rule (vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64>
DEBUG no conversion possible
DEBUG considering rule (vec3<f64>, vec3<f64>, f64) -> vec3<f64>
DEBUG no conversion possible
DEBUG considering rule (vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64>
DEBUG no conversion possible
DEBUG considering rule (vec4<f64>, vec4<f64>, f64) -> vec4<f64>
DEBUG no conversion possible
DEBUG overloads after arg 0 of type vec4<f32>: [
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
]
DEBUG arg 1 of type vec4<f32>
DEBUG considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>
DEBUG types are equivalent
DEBUG considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32>
DEBUG types are equivalent
DEBUG overloads after arg 1 of type vec4<f32>: [
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
]
DEBUG Resolving [110] = Math { fun: Mix, arg: [4], arg1: Some([5]), arg2: Some([109]), arg3: None } : Value(Vector { size: Quad, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [111] = CallResult([19]) : Handle([2])
DEBUG Resolving [112] = AccessIndex { base: [0], index: 3 } : Handle([0])
DEBUG Resolving [113] = Literal(F32(65535.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [114] = Binary { op: Divide, left: [112], right: [113] } : Handle([0])
DEBUG Resolving [115] = Literal(F32(255.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [116] = Binary { op: Divide, left: [114], right: [115] } : Handle([0])
DEBUG Resolving [117] = Literal(F32(65535.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [118] = Binary { op: Modulo, left: [112], right: [117] } : Handle([0])
DEBUG Resolving [119] = Literal(F32(255.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [120] = Binary { op: Divide, left: [118], right: [119] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [121] = Binary { op: Add, left: [116], right: [120] } : Handle([0])
DEBUG Resolving [122] = Constant([0]) : Handle([0])
DEBUG Resolving [123] = Literal(AbstractFloat(4.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [124] = Literal(F32(4.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [125] = Literal(F32(3.1415925)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [126] = Literal(F32(0.7853981)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Sin, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [127] = Math { fun: Sin, arg: [126], arg1: None, arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [128] = Binary { op: Multiply, left: [121], right: [127] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Cos, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [129] = Math { fun: Cos, arg: [126], arg1: None, arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG initial overloads for Sin, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [130] = Math { fun: Sin, arg: [126], arg1: None, arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [131] = Unary { op: Negate, expr: [130] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG initial overloads for Sin, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [132] = Math { fun: Sin, arg: [126], arg1: None, arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG initial overloads for Cos, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [133] = Math { fun: Cos, arg: [126], arg1: None, arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [134] = Compose { ty: [3], components: [[129], [131]] } : Handle([3])
DEBUG Resolving [135] = Compose { ty: [3], components: [[132], [133]] } : Handle([3])
DEBUG Resolving [136] = Compose { ty: [20], components: [[134], [135]] } : Handle([20])
DEBUG Resolving [137] = AccessIndex { base: [2], index: 0 } : Handle([3])
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [138] = Binary { op: Subtract, left: [1], right: [137] } : Handle([3])
DEBUG wgsl automatic_conversion_consensus: mat2x2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [139] = Binary { op: Multiply, left: [136], right: [138] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [140] = AccessIndex { base: [139], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [141] = Binary { op: Modulo, left: [140], right: [128] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [142] = Binary { op: Subtract, left: [128], right: [141] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Initial overloads: List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 1 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG initial overloads for Min, List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [143] = Math { fun: Min, arg: [141], arg1: Some([142]), arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [144] = Binary { op: Divide, left: [116], right: [121] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [145] = Binary { op: Multiply, left: [128], right: [144] } : Handle([0])
DEBUG Resolving [146] = Literal(F32(2.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [147] = Binary { op: Divide, left: [145], right: [146] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [148] = Binary { op: Subtract, left: [143], right: [147] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [149] = AccessIndex { base: [9], index: 3 } : Value(ValuePointer { size: None, scalar: Scalar { kind: Float, width: 4 }, space: Function })
DEBUG Resolving [150] = Literal(AbstractFloat(0.5)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [151] = Literal(F32(0.5)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [152] = Binary { op: Subtract, left: [151], right: [148] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Saturate, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [153] = Math { fun: Saturate, arg: [152], arg1: None, arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [154] = Load { pointer: [149] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [155] = Binary { op: Multiply, left: [154], right: [153] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [156] = Load { pointer: [9] } : Handle([2])
DEBUG Resolving [12] = Literal(I32(2)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [13] = Literal(AbstractInt(0)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [14] = Literal(I32(0)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [15] = Literal(AbstractInt(1)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [16] = Literal(I32(1)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [17] = Literal(AbstractInt(2)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [18] = Literal(I32(2)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [19] = Literal(AbstractInt(3)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [20] = Literal(I32(3)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [21] = Literal(AbstractInt(4)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [22] = Literal(I32(4)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [23] = Literal(AbstractInt(5)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [0] = FunctionArgument(0) : Handle([4])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([4])
DEBUG Resolving [2] = Literal(U32(1)) : Value(Scalar(Scalar { kind: Uint, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: u32, u32
DEBUG consensus: u32
DEBUG Resolving [3] = Binary { op: And, left: [0], right: [2] } : Handle([4])
DEBUG Resolving [4] = As { expr: [3], kind: Float, convert: Some(4) } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [5] = Literal(AbstractFloat(0.5)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [6] = Literal(U32(2)) : Value(Scalar(Scalar { kind: Uint, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: u32, u32
DEBUG consensus: u32
DEBUG Resolving [7] = Binary { op: And, left: [0], right: [6] } : Handle([4])
DEBUG Resolving [8] = As { expr: [7], kind: Float, convert: Some(4) } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [9] = Literal(F32(0.5)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [10] = Binary { op: Multiply, left: [9], right: [8] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [11] = Compose { ty: [3], components: [[4], [10]] } : Handle([3])
DEBUG Resolving [12] = GlobalVariable([5]) : Value(Pointer { base: [26], space: Storage { access: StorageAccess(LOAD) } })
DEBUG Resolving [13] = Access { base: [12], index: [1] } : Value(Pointer { base: [25], space: Storage { access: StorageAccess(LOAD) } })
DEBUG Resolving [14] = Load { pointer: [13] } : Handle([25])
DEBUG Resolving [15] = ZeroValue([27]) : Handle([27])
DEBUG Resolving [16] = LocalVariable([0]) : Value(Pointer { base: [27], space: Function })
DEBUG Resolving [17] = AccessIndex { base: [16], index: 0 } : Value(Pointer { base: [2], space: Function })
DEBUG Resolving [18] = AccessIndex { base: [14], index: 2 } : Handle([8])
DEBUG Resolving [19] = CallResult([6]) : Handle([2])
DEBUG Resolving [20] = AccessIndex { base: [14], index: 4 } : Handle([14])
DEBUG Resolving [21] = AccessIndex { base: [20], index: 0 } : Handle([4])
DEBUG Resolving [22] = AccessIndex { base: [14], index: 4 } : Handle([14])
DEBUG Resolving [23] = AccessIndex { base: [22], index: 1 } : Handle([4])
DEBUG Resolving [24] = AccessIndex { base: [14], index: 4 } : Handle([14])
DEBUG Resolving [25] = AccessIndex { base: [24], index: 2 } : Handle([11])
DEBUG Resolving [26] = AccessIndex { base: [14], index: 4 } : Handle([14])
DEBUG Resolving [27] = AccessIndex { base: [26], index: 4 } : Handle([13])
DEBUG Resolving [28] = CallResult([28]) : Handle([24])
DEBUG Resolving [29] = AccessIndex { base: [16], index: 4 } : Value(Pointer { base: [2], space: Function })
DEBUG Resolving [30] = AccessIndex { base: [28], index: 0 } : Handle([2])
DEBUG Resolving [31] = AccessIndex { base: [16], index: 5 } : Value(Pointer { base: [2], space: Function })
DEBUG Resolving [32] = AccessIndex { base: [28], index: 1 } : Handle([2])
DEBUG Resolving [33] = AccessIndex { base: [16], index: 6 } : Value(Pointer { base: [2], space: Function })
DEBUG Resolving [34] = AccessIndex { base: [28], index: 2 } : Handle([2])
DEBUG Resolving [35] = AccessIndex { base: [16], index: 1 } : Value(Pointer { base: [2], space: Function })
DEBUG Resolving [36] = AccessIndex { base: [14], index: 5 } : Handle([11])
DEBUG Resolving [37] = CallResult([17]) : Handle([2])
DEBUG Resolving [38] = AccessIndex { base: [16], index: 2 } : Value(Pointer { base: [4], space: Function })
DEBUG Resolving [39] = AccessIndex { base: [16], index: 3 } : Value(Pointer { base: [2], space: Function })
DEBUG Resolving [40] = AccessIndex { base: [14], index: 2 } : Handle([8])
DEBUG Resolving [41] = AccessIndex { base: [14], index: 3 } : Handle([8])
DEBUG Resolving [42] = CallResult([10]) : Handle([2])
DEBUG Resolving [43] = Load { pointer: [16] } : Handle([27])
DEBUG Resolving [0] = FunctionArgument(0) : Handle([3])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([3])
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [2] = Binary { op: Divide, left: [0], right: [1] } : Handle([3])
DEBUG Initial overloads: List {
rules: [
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<f32>) -> f32,
(vec2<f16>) -> f16,
(vec2<f64>) -> f64,
(vec3<f32>) -> f32,
(vec3<f16>) -> f16,
(vec3<f64>) -> f64,
(vec4<f32>) -> f32,
(vec4<f16>) -> f16,
(vec4<f64>) -> f64,
],
conclude: Scalar,
}
DEBUG Supplying argument 0 of type vec2<f32>
DEBUG Remaining overloads: List {
rules: [
(vec2<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG initial overloads for Length, List {
rules: [
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<f32>) -> f32,
(vec2<f16>) -> f16,
(vec2<f64>) -> f64,
(vec3<f32>) -> f32,
(vec3<f16>) -> f16,
(vec3<f64>) -> f64,
(vec4<f32>) -> f32,
(vec4<f16>) -> f16,
(vec4<f64>) -> f64,
],
conclude: Scalar,
}
DEBUG overloads after arg 0 of type vec2<f32>: List {
rules: [
(vec2<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG Resolving [3] = Math { fun: Length, arg: [2], arg1: None, arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [4] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [5] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [6] = Binary { op: Subtract, left: [3], right: [5] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [7] = AccessIndex { base: [1], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [8] = AccessIndex { base: [1], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [9] = Binary { op: Add, left: [7], right: [8] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [10] = Binary { op: Multiply, left: [6], right: [9] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [11] = Literal(AbstractFloat(0.5)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [12] = Literal(AbstractFloat(-0.5)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [13] = Literal(F32(-0.5)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [14] = Binary { op: Multiply, left: [10], right: [13] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [0] = FunctionArgument(0) : Handle([0])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([0])
DEBUG Resolving [2] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [3] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [4] = Binary { op: Equal, left: [0], right: [3] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [5] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [6] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [7] = Binary { op: Equal, left: [1], right: [6] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Initial overloads: List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 1 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Min, List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [8] = Math { fun: Min, arg: [0], arg1: Some([1]), arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [0] = FunctionArgument(0) : Handle([0])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [2] = Binary { op: Divide, left: [0], right: [1] } : Handle([0])
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Trunc, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [3] = Math { fun: Trunc, arg: [2], arg1: None, arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [4] = Binary { op: Multiply, left: [1], right: [3] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [5] = Binary { op: Subtract, left: [0], right: [4] } : Handle([0])
DEBUG Resolving [0] = FunctionArgument(0) : Handle([0])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([0])
DEBUG Resolving [2] = FunctionArgument(2) : Handle([0])
DEBUG Resolving [3] = FunctionArgument(3) : Handle([0])
DEBUG Resolving [4] = FunctionArgument(4) : Handle([0])
DEBUG Resolving [5] = Literal(AbstractInt(2)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractInt}
DEBUG consensus: f32
DEBUG Resolving [6] = Literal(F32(2.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [7] = Binary { op: Divide, left: [1], right: [6] } : Handle([0])
DEBUG Resolving [8] = Literal(AbstractInt(2)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractInt}
DEBUG consensus: f32
DEBUG Resolving [9] = Literal(F32(2.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [10] = Binary { op: Divide, left: [2], right: [9] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [11] = Binary { op: Add, left: [0], right: [7] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [12] = Binary { op: Subtract, left: [11], right: [10] } : Handle([0])
DEBUG Resolving [13] = CallResult([32]) : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [14] = Binary { op: Subtract, left: [13], right: [7] } : Handle([0])
DEBUG Initial overloads: List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Abs, List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [15] = Math { fun: Abs, arg: [14], arg1: None, arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [16] = Binary { op: Subtract, left: [15], right: [10] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [17] = Binary { op: Divide, left: [16], right: [3] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [18] = Binary { op: Subtract, left: [4], right: [17] } : Handle([0])
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Saturate, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [19] = Math { fun: Saturate, arg: [18], arg1: None, arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [24] = Literal(I32(5)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [25] = Literal(AbstractInt(0)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [0] = FunctionArgument(0) : Handle([27])
DEBUG Resolving [1] = AccessIndex { base: [0], index: 3 } : Handle([2])
DEBUG Resolving [2] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [3] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [4] = Splat { size: Quad, value: [3] } : Value(Vector { size: Quad, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec4<f32>, vec4<f32>
DEBUG consensus: f32
DEBUG Resolving [5] = Binary { op: Less, left: [1], right: [4] } : Value(Vector { size: Quad, scalar: Scalar { kind: Bool, width: 1 } })
DEBUG Resolving [6] = Relational { fun: Any, argument: [5] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [7] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [8] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [9] = Splat { size: Quad, value: [8] } : Value(Vector { size: Quad, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [10] = GlobalVariable([5]) : Value(Pointer { base: [26], space: Storage { access: StorageAccess(LOAD) } })
DEBUG Resolving [11] = AccessIndex { base: [0], index: 2 } : Handle([4])
DEBUG Resolving [12] = Access { base: [10], index: [11] } : Value(Pointer { base: [25], space: Storage { access: StorageAccess(LOAD) } })
DEBUG Resolving [13] = Load { pointer: [12] } : Handle([25])
DEBUG Resolving [14] = AccessIndex { base: [13], index: 4 } : Handle([14])
DEBUG Resolving [15] = AccessIndex { base: [0], index: 0 } : Handle([2])
DEBUG Resolving [16] = Swizzle { size: Bi, vector: [15], pattern: [X, Y, X, X] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [17] = AccessIndex { base: [13], index: 2 } : Handle([8])
DEBUG Resolving [18] = AccessIndex { base: [0], index: 4 } : Handle([2])
DEBUG Resolving [19] = AccessIndex { base: [0], index: 5 } : Handle([2])
DEBUG Resolving [20] = AccessIndex { base: [0], index: 6 } : Handle([2])
DEBUG Resolving [21] = CallResult([29]) : Handle([2])
DEBUG Resolving [22] = AccessIndex { base: [13], index: 6 } : Handle([9])
DEBUG Resolving [23] = AccessIndex { base: [22], index: 0 } : Handle([0])
DEBUG Resolving [24] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [25] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [26] = Binary { op: Equal, left: [23], right: [25] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [27] = AccessIndex { base: [13], index: 6 } : Handle([9])
DEBUG Resolving [28] = AccessIndex { base: [27], index: 3 } : Handle([0])
DEBUG Resolving [29] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [30] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [31] = Binary { op: Equal, left: [28], right: [30] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG wgsl automatic_conversion_consensus: bool, bool
DEBUG consensus: bool
DEBUG Resolving [32] = Binary { op: LogicalAnd, left: [26], right: [31] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [33] = AccessIndex { base: [13], index: 6 } : Handle([9])
DEBUG Resolving [34] = AccessIndex { base: [33], index: 1 } : Handle([0])
DEBUG Resolving [35] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [36] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [37] = Binary { op: Equal, left: [34], right: [36] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG wgsl automatic_conversion_consensus: bool, bool
DEBUG consensus: bool
DEBUG Resolving [38] = Binary { op: LogicalAnd, left: [32], right: [37] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [39] = AccessIndex { base: [13], index: 6 } : Handle([9])
DEBUG Resolving [40] = AccessIndex { base: [39], index: 2 } : Handle([0])
DEBUG Resolving [41] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [42] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [43] = Binary { op: Equal, left: [40], right: [42] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG wgsl automatic_conversion_consensus: bool, bool
DEBUG consensus: bool
DEBUG Resolving [44] = Binary { op: LogicalAnd, left: [38], right: [43] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [45] = AccessIndex { base: [13], index: 7 } : Handle([10])
DEBUG Resolving [46] = AccessIndex { base: [45], index: 0 } : Handle([0])
DEBUG Resolving [47] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [48] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [49] = Binary { op: Equal, left: [46], right: [48] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [50] = AccessIndex { base: [13], index: 7 } : Handle([10])
DEBUG Resolving [51] = AccessIndex { base: [50], index: 3 } : Handle([0])
DEBUG Resolving [52] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [53] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [54] = Binary { op: Equal, left: [51], right: [53] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG wgsl automatic_conversion_consensus: bool, bool
DEBUG consensus: bool
DEBUG Resolving [55] = Binary { op: LogicalAnd, left: [49], right: [54] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [56] = AccessIndex { base: [13], index: 7 } : Handle([10])
DEBUG Resolving [57] = AccessIndex { base: [56], index: 1 } : Handle([0])
DEBUG Resolving [58] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [59] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [60] = Binary { op: Equal, left: [57], right: [59] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG wgsl automatic_conversion_consensus: bool, bool
DEBUG consensus: bool
DEBUG Resolving [61] = Binary { op: LogicalAnd, left: [55], right: [60] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [62] = AccessIndex { base: [13], index: 7 } : Handle([10])
DEBUG Resolving [63] = AccessIndex { base: [62], index: 2 } : Handle([0])
DEBUG Resolving [64] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [65] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [66] = Binary { op: Equal, left: [63], right: [65] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG wgsl automatic_conversion_consensus: bool, bool
DEBUG consensus: bool
DEBUG Resolving [67] = Binary { op: LogicalAnd, left: [61], right: [66] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG wgsl automatic_conversion_consensus: bool, bool
DEBUG consensus: bool
DEBUG Resolving [68] = Binary { op: LogicalAnd, left: [67], right: [44] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [69] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [70] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [71] = CallResult([27]) : Handle([2])
DEBUG Resolving [72] = AccessIndex { base: [13], index: 2 } : Handle([8])
DEBUG Resolving [73] = AccessIndex { base: [72], index: 1 } : Handle([3])
DEBUG Resolving [74] = Literal(AbstractFloat(2.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [75] = Splat { size: Bi, value: [74] } : Value(Vector { size: Bi, scalar: Scalar { kind: AbstractFloat, width: 8 } })
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<{AbstractFloat}>
DEBUG consensus: f32
DEBUG Resolving [76] = Literal(F32(2.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [77] = Splat { size: Bi, value: [76] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [78] = Binary { op: Divide, left: [73], right: [77] } : Handle([3])
DEBUG Resolving [79] = AccessIndex { base: [0], index: 0 } : Handle([2])
DEBUG Resolving [80] = Swizzle { size: Bi, vector: [79], pattern: [X, Y, X, X] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [81] = AccessIndex { base: [13], index: 2 } : Handle([8])
DEBUG Resolving [82] = AccessIndex { base: [81], index: 0 } : Handle([3])
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [83] = Binary { op: Subtract, left: [80], right: [82] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [84] = Binary { op: Subtract, left: [83], right: [78] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [85] = Literal(AbstractFloat(0.5)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [86] = Literal(F32(0.5)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [87] = AccessIndex { base: [13], index: 6 } : Handle([9])
DEBUG Resolving [88] = CallResult([24]) : Handle([0])
DEBUG Resolving [89] = AccessIndex { base: [13], index: 7 } : Handle([10])
DEBUG Resolving [90] = AccessIndex { base: [89], index: 1 } : Handle([0])
DEBUG Resolving [91] = AccessIndex { base: [13], index: 7 } : Handle([10])
DEBUG Resolving [92] = AccessIndex { base: [91], index: 3 } : Handle([0])
DEBUG Resolving [93] = AccessIndex { base: [84], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [94] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [95] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [96] = Binary { op: Less, left: [93], right: [95] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [97] = Select { condition: [96], accept: [92], reject: [90] } : Handle([0])
DEBUG Resolving [98] = AccessIndex { base: [13], index: 7 } : Handle([10])
DEBUG Resolving [99] = AccessIndex { base: [98], index: 2 } : Handle([0])
DEBUG Resolving [100] = AccessIndex { base: [13], index: 7 } : Handle([10])
DEBUG Resolving [101] = AccessIndex { base: [100], index: 0 } : Handle([0])
DEBUG Resolving [102] = AccessIndex { base: [84], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [103] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [104] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [105] = Binary { op: Less, left: [102], right: [104] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [106] = Select { condition: [105], accept: [101], reject: [99] } : Handle([0])
DEBUG Resolving [107] = Compose { ty: [3], components: [[97], [106]] } : Handle([3])
DEBUG Resolving [108] = AccessIndex { base: [107], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [109] = Unary { op: Negate, expr: [86] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [110] = AccessIndex { base: [107], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [111] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [112] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [113] = Binary { op: Equal, left: [110], right: [112] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [114] = Select { condition: [113], accept: [109], reject: [108] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [115] = AccessIndex { base: [107], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [116] = Unary { op: Negate, expr: [86] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [117] = AccessIndex { base: [107], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [118] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [119] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [120] = Binary { op: Equal, left: [117], right: [119] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [121] = Select { condition: [120], accept: [116], reject: [115] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [122] = Compose { ty: [3], components: [[114], [121]] } : Handle([3])
DEBUG Initial overloads: List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type vec2<f32>
DEBUG Remaining overloads: List {
rules: [
(vec2<f32>) -> vec2<f32>,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Abs, List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type vec2<f32>: List {
rules: [
(vec2<f32>) -> vec2<f32>,
],
conclude: ArgumentType,
}
DEBUG Resolving [123] = Math { fun: Abs, arg: [84], arg1: None, arg2: None, arg3: None } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [124] = Binary { op: Subtract, left: [123], right: [78] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [125] = Splat { size: Bi, value: [88] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [126] = Binary { op: Add, left: [124], right: [125] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [127] = AccessIndex { base: [126], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [128] = Literal(AbstractInt(0)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractInt}
DEBUG consensus: f32
DEBUG Resolving [129] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [130] = Binary { op: GreaterEqual, left: [127], right: [129] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [131] = AccessIndex { base: [126], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [132] = Literal(AbstractInt(0)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractInt}
DEBUG consensus: f32
DEBUG Resolving [133] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [134] = Binary { op: GreaterEqual, left: [131], right: [133] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG wgsl automatic_conversion_consensus: bool, bool
DEBUG consensus: bool
DEBUG Resolving [135] = Binary { op: LogicalAnd, left: [130], right: [134] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [136] = Binary { op: Add, left: [124], right: [122] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [137] = AccessIndex { base: [136], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [138] = Literal(AbstractInt(0)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractInt}
DEBUG consensus: f32
DEBUG Resolving [139] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [140] = Binary { op: Greater, left: [137], right: [139] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [141] = AccessIndex { base: [136], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [142] = Literal(AbstractInt(0)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractInt}
DEBUG consensus: f32
DEBUG Resolving [143] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [144] = Binary { op: Greater, left: [141], right: [143] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG wgsl automatic_conversion_consensus: bool, bool
DEBUG consensus: bool
DEBUG Resolving [145] = Binary { op: LogicalOr, left: [140], right: [144] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [146] = AccessIndex { base: [136], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [147] = Unary { op: Negate, expr: [86] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [148] = Binary { op: Less, left: [146], right: [147] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [149] = AccessIndex { base: [136], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [150] = Unary { op: Negate, expr: [86] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [151] = Binary { op: Less, left: [149], right: [150] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG wgsl automatic_conversion_consensus: bool, bool
DEBUG consensus: bool
DEBUG Resolving [152] = Binary { op: LogicalAnd, left: [148], right: [151] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [153] = Unary { op: LogicalNot, expr: [135] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG wgsl automatic_conversion_consensus: bool, bool
DEBUG consensus: bool
DEBUG Resolving [154] = Binary { op: LogicalAnd, left: [152], right: [153] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [155] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [156] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [157] = CallResult([27]) : Handle([2])
DEBUG Resolving [158] = CallResult([25]) : Handle([0])
DEBUG Resolving [159] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [160] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [161] = LocalVariable([0]) : Value(Pointer { base: [0], space: Function })
DEBUG Resolving [162] = AccessIndex { base: [126], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [163] = Literal(AbstractInt(0)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractInt}
DEBUG consensus: f32
DEBUG Resolving [164] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [165] = Binary { op: LessEqual, left: [162], right: [164] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [166] = AccessIndex { base: [126], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [167] = Literal(AbstractInt(0)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractInt}
DEBUG consensus: f32
DEBUG Resolving [168] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [169] = Binary { op: LessEqual, left: [166], right: [168] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG wgsl automatic_conversion_consensus: bool, bool
DEBUG consensus: bool
DEBUG Resolving [170] = Binary { op: LogicalOr, left: [165], right: [169] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [171] = AccessIndex { base: [136], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [172] = AccessIndex { base: [136], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Initial overloads: List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 1 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Max, List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [173] = Math { fun: Max, arg: [171], arg1: Some([172]), arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [174] = Unary { op: Negate, expr: [173] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [175] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [176] = Literal(AbstractFloat(-1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [177] = Literal(F32(-1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [178] = AccessIndex { base: [122], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [179] = AccessIndex { base: [122], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [180] = Binary { op: Equal, left: [178], right: [179] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [181] = AccessIndex { base: [122], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [182] = Binary { op: Add, left: [158], right: [181] } : Handle([0])
DEBUG Resolving [183] = Unary { op: Negate, expr: [182] } : Handle([0])
DEBUG Resolving [184] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [185] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [186] = Splat { size: Bi, value: [185] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [187] = Splat { size: Bi, value: [88] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [188] = Binary { op: Subtract, left: [187], right: [122] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Initial overloads: List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type vec2<f32>
DEBUG Remaining overloads: List {
rules: [
(vec2<f32>, vec2<f32>) -> vec2<f32>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 1 of type vec2<f32>
DEBUG Remaining overloads: List {
rules: [
(vec2<f32>, vec2<f32>) -> vec2<f32>,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Max, List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type vec2<f32>: List {
rules: [
(vec2<f32>, vec2<f32>) -> vec2<f32>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type vec2<f32>: List {
rules: [
(vec2<f32>, vec2<f32>) -> vec2<f32>,
],
conclude: ArgumentType,
}
DEBUG Resolving [189] = Math { fun: Max, arg: [186], arg1: Some([188]), arg2: None, arg3: None } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [190] = CallResult([30]) : Handle([0])
DEBUG Resolving [191] = Load { pointer: [161] } : Handle([0])
DEBUG Initial overloads: List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 1 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Max, List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [192] = Math { fun: Max, arg: [191], arg1: Some([158]), arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [193] = LocalVariable([1]) : Value(Pointer { base: [2], space: Function })
DEBUG Resolving [194] = Binary { op: Less, left: [192], right: [86] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [195] = AccessIndex { base: [0], index: 1 } : Handle([2])
DEBUG Resolving [196] = LocalVariable([2]) : Value(Pointer { base: [2], space: Function })
DEBUG Resolving [197] = AccessIndex { base: [13], index: 1 } : Handle([4])
DEBUG Resolving [198] = Literal(AbstractInt(1)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: u32, {AbstractInt}
DEBUG consensus: u32
DEBUG Resolving [199] = Literal(U32(1)) : Value(Scalar(Scalar { kind: Uint, width: 4 }))
DEBUG Resolving [200] = Binary { op: Equal, left: [197], right: [199] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [201] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [202] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [203] = LocalVariable([3]) : Value(Pointer { base: [0], space: Function })
DEBUG Resolving [204] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [205] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [206] = LocalVariable([4]) : Value(Pointer { base: [0], space: Function })
DEBUG Resolving [207] = Literal(AbstractFloat(2.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [208] = Literal(F32(2.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [209] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [210] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [211] = Binary { op: Add, left: [208], right: [210] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [212] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [213] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [214] = LocalVariable([5]) : Value(Pointer { base: [0], space: Function })
DEBUG Resolving [215] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [216] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [217] = Binary { op: Divide, left: [216], right: [211] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [218] = AccessIndex { base: [126], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [219] = AccessIndex { base: [126], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [220] = Binary { op: Less, left: [218], right: [219] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [221] = AccessIndex { base: [13], index: 7 } : Handle([10])
DEBUG Resolving [222] = AccessIndex { base: [221], index: 2 } : Handle([0])
DEBUG Resolving [223] = AccessIndex { base: [13], index: 7 } : Handle([10])
DEBUG Resolving [224] = AccessIndex { base: [223], index: 0 } : Handle([0])
DEBUG Initial overloads: List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 1 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Max, List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [225] = Math { fun: Max, arg: [222], arg1: Some([224]), arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [226] = AccessIndex { base: [13], index: 7 } : Handle([10])
DEBUG Resolving [227] = AccessIndex { base: [226], index: 1 } : Handle([0])
DEBUG Resolving [228] = AccessIndex { base: [13], index: 7 } : Handle([10])
DEBUG Resolving [229] = AccessIndex { base: [228], index: 3 } : Handle([0])
DEBUG Initial overloads: List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 1 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Max, List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [230] = Math { fun: Max, arg: [227], arg1: Some([229]), arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [231] = Compose { ty: [3], components: [[225], [230]] } : Handle([3])
DEBUG Resolving [232] = AccessIndex { base: [231], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [233] = AccessIndex { base: [231], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [234] = Select { condition: [220], accept: [233], reject: [232] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [235] = Binary { op: Divide, left: [217], right: [234] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [236] = AccessIndex { base: [83], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [237] = AccessIndex { base: [83], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [238] = Select { condition: [220], accept: [237], reject: [236] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [239] = Load { pointer: [214] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [240] = Binary { op: Multiply, left: [238], right: [239] } : Handle([0])
DEBUG Resolving [241] = AccessIndex { base: [73], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [242] = AccessIndex { base: [73], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [243] = Select { condition: [220], accept: [242], reject: [241] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [244] = Load { pointer: [214] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [245] = Binary { op: Multiply, left: [243], right: [244] } : Handle([0])
DEBUG Resolving [246] = AccessIndex { base: [13], index: 6 } : Handle([9])
DEBUG Resolving [247] = AccessIndex { base: [246], index: 1 } : Handle([0])
DEBUG Resolving [248] = AccessIndex { base: [13], index: 6 } : Handle([9])
DEBUG Resolving [249] = AccessIndex { base: [248], index: 2 } : Handle([0])
DEBUG Resolving [250] = AccessIndex { base: [13], index: 6 } : Handle([9])
DEBUG Resolving [251] = AccessIndex { base: [250], index: 3 } : Handle([0])
DEBUG Resolving [252] = AccessIndex { base: [13], index: 6 } : Handle([9])
DEBUG Resolving [253] = AccessIndex { base: [252], index: 0 } : Handle([0])
DEBUG Resolving [254] = AccessIndex { base: [13], index: 7 } : Handle([10])
DEBUG Resolving [255] = AccessIndex { base: [254], index: 0 } : Handle([0])
DEBUG Resolving [256] = AccessIndex { base: [13], index: 7 } : Handle([10])
DEBUG Resolving [257] = AccessIndex { base: [256], index: 1 } : Handle([0])
DEBUG Resolving [258] = AccessIndex { base: [13], index: 7 } : Handle([10])
DEBUG Resolving [259] = AccessIndex { base: [258], index: 2 } : Handle([0])
DEBUG Resolving [260] = AccessIndex { base: [13], index: 7 } : Handle([10])
DEBUG Resolving [261] = AccessIndex { base: [260], index: 3 } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [262] = Binary { op: Divide, left: [217], right: [255] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [263] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [264] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [265] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [266] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [267] = Binary { op: LessEqual, left: [255], right: [266] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [268] = Select { condition: [267], accept: [264], reject: [262] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [269] = Binary { op: Divide, left: [217], right: [257] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [270] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [271] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [272] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [273] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [274] = Binary { op: LessEqual, left: [257], right: [273] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [275] = Select { condition: [274], accept: [271], reject: [269] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [276] = Binary { op: Divide, left: [217], right: [259] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [277] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [278] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [279] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [280] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [281] = Binary { op: LessEqual, left: [259], right: [280] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [282] = Select { condition: [281], accept: [278], reject: [276] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [283] = Binary { op: Divide, left: [217], right: [261] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [284] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [285] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [286] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [287] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [288] = Binary { op: LessEqual, left: [261], right: [287] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [289] = Select { condition: [288], accept: [285], reject: [283] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [290] = AccessIndex { base: [73], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [291] = Binary { op: Subtract, left: [290], right: [253] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [292] = Binary { op: Subtract, left: [291], right: [247] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [293] = Binary { op: Multiply, left: [292], right: [268] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [294] = AccessIndex { base: [73], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [295] = Binary { op: Subtract, left: [294], right: [247] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [296] = Binary { op: Subtract, left: [295], right: [249] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [297] = Binary { op: Multiply, left: [296], right: [275] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [298] = AccessIndex { base: [73], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [299] = Binary { op: Subtract, left: [298], right: [249] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [300] = Binary { op: Subtract, left: [299], right: [251] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [301] = Binary { op: Multiply, left: [300], right: [282] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [302] = AccessIndex { base: [73], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [303] = Binary { op: Subtract, left: [302], right: [251] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [304] = Binary { op: Subtract, left: [303], right: [253] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [305] = Binary { op: Multiply, left: [304], right: [289] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [306] = CallResult([31]) : Handle([0])
DEBUG Resolving [307] = CallResult([31]) : Handle([0])
DEBUG Resolving [308] = CallResult([31]) : Handle([0])
DEBUG Resolving [309] = CallResult([31]) : Handle([0])
DEBUG Resolving [310] = Constant([0]) : Handle([0])
DEBUG Resolving [311] = Literal(AbstractFloat(2.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [312] = Literal(F32(2.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [313] = Literal(F32(3.1415925)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [314] = Literal(F32(1.5707963)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [315] = Binary { op: Multiply, left: [247], right: [314] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [316] = Binary { op: Multiply, left: [315], right: [306] } : Handle([0])
DEBUG Resolving [317] = Constant([0]) : Handle([0])
DEBUG Resolving [318] = Literal(AbstractFloat(2.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [319] = Literal(F32(2.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [320] = Literal(F32(3.1415925)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [321] = Literal(F32(1.5707963)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [322] = Binary { op: Multiply, left: [249], right: [321] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [323] = Binary { op: Multiply, left: [322], right: [307] } : Handle([0])
DEBUG Resolving [324] = Constant([0]) : Handle([0])
DEBUG Resolving [325] = Literal(AbstractFloat(2.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [326] = Literal(F32(2.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [327] = Literal(F32(3.1415925)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [328] = Literal(F32(1.5707963)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [329] = Binary { op: Multiply, left: [251], right: [328] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [330] = Binary { op: Multiply, left: [329], right: [308] } : Handle([0])
DEBUG Resolving [331] = Constant([0]) : Handle([0])
DEBUG Resolving [332] = Literal(AbstractFloat(2.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [333] = Literal(F32(2.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [334] = Literal(F32(3.1415925)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [335] = Literal(F32(1.5707963)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [336] = Binary { op: Multiply, left: [253], right: [335] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [337] = Binary { op: Multiply, left: [336], right: [309] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [338] = Binary { op: Add, left: [293], right: [316] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [339] = Binary { op: Add, left: [338], right: [297] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [340] = Binary { op: Add, left: [339], right: [323] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [341] = Binary { op: Add, left: [340], right: [301] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [342] = Binary { op: Add, left: [341], right: [330] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [343] = Binary { op: Add, left: [342], right: [305] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [344] = Binary { op: Add, left: [343], right: [337] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [345] = AccessIndex { base: [126], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [346] = AccessIndex { base: [126], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 1 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Atan2, List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [347] = Math { fun: Atan2, arg: [345], arg1: Some([346]), arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [348] = Binary { op: Multiply, left: [347], right: [88] } : Handle([0])
DEBUG Resolving [349] = AccessIndex { base: [84], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [350] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [351] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [352] = Binary { op: GreaterEqual, left: [349], right: [351] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [353] = AccessIndex { base: [84], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [354] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [355] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [356] = Binary { op: Less, left: [353], right: [355] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [357] = Load { pointer: [214] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [358] = Binary { op: Multiply, left: [348], right: [357] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [359] = Binary { op: Subtract, left: [338], right: [358] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [360] = Load { pointer: [214] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [361] = Binary { op: Multiply, left: [348], right: [360] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [362] = Binary { op: Add, left: [339], right: [361] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [363] = AccessIndex { base: [84], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [364] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [365] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [366] = Binary { op: GreaterEqual, left: [363], right: [365] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [367] = Load { pointer: [214] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [368] = Binary { op: Multiply, left: [348], right: [367] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [369] = Binary { op: Subtract, left: [342], right: [368] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [370] = Load { pointer: [214] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [371] = Binary { op: Multiply, left: [348], right: [370] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [372] = Binary { op: Add, left: [343], right: [371] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [373] = AccessIndex { base: [126], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [374] = AccessIndex { base: [126], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [375] = Binary { op: Less, left: [373], right: [374] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [376] = AccessIndex { base: [84], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [377] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [378] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [379] = Binary { op: Less, left: [376], right: [378] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [380] = AccessIndex { base: [83], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [381] = Binary { op: Subtract, left: [380], right: [253] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [382] = Load { pointer: [214] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [383] = Binary { op: Multiply, left: [381], right: [382] } : Handle([0])
DEBUG Resolving [384] = AccessIndex { base: [83], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [385] = Binary { op: Subtract, left: [384], right: [251] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [386] = Load { pointer: [214] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [387] = Binary { op: Multiply, left: [385], right: [386] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [388] = Binary { op: Subtract, left: [341], right: [387] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [389] = AccessIndex { base: [84], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [390] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [391] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [392] = Binary { op: Less, left: [389], right: [391] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [393] = AccessIndex { base: [83], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [394] = Binary { op: Subtract, left: [393], right: [253] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [395] = Load { pointer: [214] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [396] = Binary { op: Multiply, left: [394], right: [395] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [397] = Binary { op: Subtract, left: [343], right: [396] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [398] = AccessIndex { base: [83], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [399] = Binary { op: Subtract, left: [398], right: [247] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [400] = Load { pointer: [214] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [401] = Binary { op: Multiply, left: [399], right: [400] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [402] = Binary { op: Add, left: [338], right: [401] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [403] = Binary { op: Divide, left: [208], right: [211] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [404] = Binary { op: Divide, left: [210], right: [211] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [405] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [406] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [407] = Select { condition: [44], accept: [403], reject: [406] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [408] = Load { pointer: [206] } : Handle([0])
DEBUG Resolving [409] = Binary { op: Subtract, left: [408], right: [407] } : Handle([0])
DEBUG Resolving [410] = Load { pointer: [206] } : Handle([0])
DEBUG Resolving [411] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [412] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [413] = Binary { op: GreaterEqual, left: [410], right: [412] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [414] = Load { pointer: [206] } : Handle([0])
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Floor, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [415] = Math { fun: Floor, arg: [414], arg1: None, arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [416] = Load { pointer: [206] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [417] = Binary { op: Divide, left: [416], right: [415] } : Handle([0])
DEBUG Resolving [418] = AccessIndex { base: [196], index: 3 } : Value(ValuePointer { size: None, scalar: Scalar { kind: Float, width: 4 }, space: Function })
DEBUG Resolving [419] = Load { pointer: [203] } : Handle([0])
DEBUG Resolving [420] = Load { pointer: [214] } : Handle([0])
DEBUG Resolving [421] = CallResult([33]) : Handle([0])
DEBUG Resolving [422] = Load { pointer: [418] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [423] = Binary { op: Multiply, left: [422], right: [421] } : Handle([0])
DEBUG Resolving [424] = Load { pointer: [206] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [425] = Binary { op: Subtract, left: [424], right: [403] } : Handle([0])
DEBUG Resolving [426] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [427] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [428] = Binary { op: Greater, left: [425], right: [427] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [429] = Binary { op: Add, left: [403], right: [425] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [430] = AccessIndex { base: [196], index: 3 } : Value(ValuePointer { size: None, scalar: Scalar { kind: Float, width: 4 }, space: Function })
DEBUG Resolving [431] = Load { pointer: [203] } : Handle([0])
DEBUG Resolving [432] = Load { pointer: [214] } : Handle([0])
DEBUG Resolving [433] = CallResult([33]) : Handle([0])
DEBUG Resolving [434] = Load { pointer: [430] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [435] = Binary { op: Multiply, left: [434], right: [433] } : Handle([0])
DEBUG Resolving [436] = Load { pointer: [196] } : Handle([2])
DEBUG Resolving [437] = CallResult([20]) : Handle([2])
DEBUG Resolving [438] = Load { pointer: [161] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [439] = Binary { op: Subtract, left: [86], right: [438] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Saturate, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [440] = Math { fun: Saturate, arg: [439], arg1: None, arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Initial overloads: [
({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, {AbstractFloat}) -> vec2<{AbstractFloat}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, {AbstractFloat}) -> vec3<{AbstractFloat}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, {AbstractFloat}) -> vec4<{AbstractFloat}>,
(f32, f32, f32) -> f32,
(f32, f32, f32) -> f32,
(vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f32>, vec2<f32>, f32) -> vec2<f32>,
(vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f32>, vec3<f32>, f32) -> vec3<f32>,
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
(f16, f16, f16) -> f16,
(f16, f16, f16) -> f16,
(vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f16>, vec2<f16>, f16) -> vec2<f16>,
(vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f16>, vec3<f16>, f16) -> vec3<f16>,
(vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f16>, vec4<f16>, f16) -> vec4<f16>,
(f64, f64, f64) -> f64,
(f64, f64, f64) -> f64,
(vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec2<f64>, vec2<f64>, f64) -> vec2<f64>,
(vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec3<f64>, vec3<f64>, f64) -> vec3<f64>,
(vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64>,
(vec4<f64>, vec4<f64>, f64) -> vec4<f64>,
]
DEBUG Supplying argument 0 of type vec4<f32>
DEBUG arg 0 of type vec4<f32>
DEBUG considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat}
DEBUG no conversion possible
DEBUG considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat}
DEBUG no conversion possible
DEBUG considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, {AbstractFloat}) -> vec2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, {AbstractFloat}) -> vec3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, {AbstractFloat}) -> vec4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (f32, f32, f32) -> f32
DEBUG no conversion possible
DEBUG considering rule (f32, f32, f32) -> f32
DEBUG no conversion possible
DEBUG considering rule (vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32>
DEBUG no conversion possible
DEBUG considering rule (vec2<f32>, vec2<f32>, f32) -> vec2<f32>
DEBUG no conversion possible
DEBUG considering rule (vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32>
DEBUG no conversion possible
DEBUG considering rule (vec3<f32>, vec3<f32>, f32) -> vec3<f32>
DEBUG no conversion possible
DEBUG considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>
DEBUG types are equivalent
DEBUG considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32>
DEBUG types are equivalent
DEBUG considering rule (f16, f16, f16) -> f16
DEBUG no conversion possible
DEBUG considering rule (f16, f16, f16) -> f16
DEBUG no conversion possible
DEBUG considering rule (vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16>
DEBUG no conversion possible
DEBUG considering rule (vec2<f16>, vec2<f16>, f16) -> vec2<f16>
DEBUG no conversion possible
DEBUG considering rule (vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16>
DEBUG no conversion possible
DEBUG considering rule (vec3<f16>, vec3<f16>, f16) -> vec3<f16>
DEBUG no conversion possible
DEBUG considering rule (vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16>
DEBUG no conversion possible
DEBUG considering rule (vec4<f16>, vec4<f16>, f16) -> vec4<f16>
DEBUG no conversion possible
DEBUG considering rule (f64, f64, f64) -> f64
DEBUG no conversion possible
DEBUG considering rule (f64, f64, f64) -> f64
DEBUG no conversion possible
DEBUG considering rule (vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64>
DEBUG no conversion possible
DEBUG considering rule (vec2<f64>, vec2<f64>, f64) -> vec2<f64>
DEBUG no conversion possible
DEBUG considering rule (vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64>
DEBUG no conversion possible
DEBUG considering rule (vec3<f64>, vec3<f64>, f64) -> vec3<f64>
DEBUG no conversion possible
DEBUG considering rule (vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64>
DEBUG no conversion possible
DEBUG considering rule (vec4<f64>, vec4<f64>, f64) -> vec4<f64>
DEBUG no conversion possible
DEBUG Remaining overloads: [
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
]
DEBUG Supplying argument 1 of type vec4<f32>
DEBUG arg 1 of type vec4<f32>
DEBUG considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>
DEBUG types are equivalent
DEBUG considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32>
DEBUG types are equivalent
DEBUG Remaining overloads: [
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
]
DEBUG Supplying argument 2 of type f32
DEBUG arg 2 of type f32
DEBUG considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>
DEBUG no conversion possible
DEBUG considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32>
DEBUG types are equivalent
DEBUG Remaining overloads: [
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
]
DEBUG initial overloads for Mix, [
({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, {AbstractFloat}) -> vec2<{AbstractFloat}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, {AbstractFloat}) -> vec3<{AbstractFloat}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, {AbstractFloat}) -> vec4<{AbstractFloat}>,
(f32, f32, f32) -> f32,
(f32, f32, f32) -> f32,
(vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f32>, vec2<f32>, f32) -> vec2<f32>,
(vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f32>, vec3<f32>, f32) -> vec3<f32>,
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
(f16, f16, f16) -> f16,
(f16, f16, f16) -> f16,
(vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f16>, vec2<f16>, f16) -> vec2<f16>,
(vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f16>, vec3<f16>, f16) -> vec3<f16>,
(vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f16>, vec4<f16>, f16) -> vec4<f16>,
(f64, f64, f64) -> f64,
(f64, f64, f64) -> f64,
(vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec2<f64>, vec2<f64>, f64) -> vec2<f64>,
(vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec3<f64>, vec3<f64>, f64) -> vec3<f64>,
(vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64>,
(vec4<f64>, vec4<f64>, f64) -> vec4<f64>,
]
DEBUG arg 0 of type vec4<f32>
DEBUG considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat}
DEBUG no conversion possible
DEBUG considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat}
DEBUG no conversion possible
DEBUG considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, {AbstractFloat}) -> vec2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, {AbstractFloat}) -> vec3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, {AbstractFloat}) -> vec4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (f32, f32, f32) -> f32
DEBUG no conversion possible
DEBUG considering rule (f32, f32, f32) -> f32
DEBUG no conversion possible
DEBUG considering rule (vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32>
DEBUG no conversion possible
DEBUG considering rule (vec2<f32>, vec2<f32>, f32) -> vec2<f32>
DEBUG no conversion possible
DEBUG considering rule (vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32>
DEBUG no conversion possible
DEBUG considering rule (vec3<f32>, vec3<f32>, f32) -> vec3<f32>
DEBUG no conversion possible
DEBUG considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>
DEBUG types are equivalent
DEBUG considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32>
DEBUG types are equivalent
DEBUG considering rule (f16, f16, f16) -> f16
DEBUG no conversion possible
DEBUG considering rule (f16, f16, f16) -> f16
DEBUG no conversion possible
DEBUG considering rule (vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16>
DEBUG no conversion possible
DEBUG considering rule (vec2<f16>, vec2<f16>, f16) -> vec2<f16>
DEBUG no conversion possible
DEBUG considering rule (vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16>
DEBUG no conversion possible
DEBUG considering rule (vec3<f16>, vec3<f16>, f16) -> vec3<f16>
DEBUG no conversion possible
DEBUG considering rule (vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16>
DEBUG no conversion possible
DEBUG considering rule (vec4<f16>, vec4<f16>, f16) -> vec4<f16>
DEBUG no conversion possible
DEBUG considering rule (f64, f64, f64) -> f64
DEBUG no conversion possible
DEBUG considering rule (f64, f64, f64) -> f64
DEBUG no conversion possible
DEBUG considering rule (vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64>
DEBUG no conversion possible
DEBUG considering rule (vec2<f64>, vec2<f64>, f64) -> vec2<f64>
DEBUG no conversion possible
DEBUG considering rule (vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64>
DEBUG no conversion possible
DEBUG considering rule (vec3<f64>, vec3<f64>, f64) -> vec3<f64>
DEBUG no conversion possible
DEBUG considering rule (vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64>
DEBUG no conversion possible
DEBUG considering rule (vec4<f64>, vec4<f64>, f64) -> vec4<f64>
DEBUG no conversion possible
DEBUG overloads after arg 0 of type vec4<f32>: [
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
]
DEBUG arg 1 of type vec4<f32>
DEBUG considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>
DEBUG types are equivalent
DEBUG considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32>
DEBUG types are equivalent
DEBUG overloads after arg 1 of type vec4<f32>: [
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
]
DEBUG Resolving [441] = Math { fun: Mix, arg: [21], arg1: Some([437]), arg2: Some([440]), arg3: None } : Value(Vector { size: Quad, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [442] = Load { pointer: [193] } : Handle([2])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [443] = Binary { op: Subtract, left: [86], right: [158] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Saturate, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [444] = Math { fun: Saturate, arg: [443], arg1: None, arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [445] = CallResult([27]) : Handle([2])
DEBUG Resolving [26] = Literal(I32(0)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [27] = Literal(AbstractInt(0)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [28] = Literal(I32(0)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [29] = Literal(AbstractInt(1)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [30] = Literal(I32(1)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [31] = Literal(AbstractInt(3)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [0] = FunctionArgument(0) : Handle([4])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([4])
DEBUG Resolving [2] = Literal(U32(1)) : Value(Scalar(Scalar { kind: Uint, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: u32, u32
DEBUG consensus: u32
DEBUG Resolving [3] = Binary { op: And, left: [0], right: [2] } : Handle([4])
DEBUG Resolving [4] = As { expr: [3], kind: Float, convert: Some(4) } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [5] = Literal(AbstractFloat(0.5)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [6] = Literal(U32(2)) : Value(Scalar(Scalar { kind: Uint, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: u32, u32
DEBUG consensus: u32
DEBUG Resolving [7] = Binary { op: And, left: [0], right: [6] } : Handle([4])
DEBUG Resolving [8] = As { expr: [7], kind: Float, convert: Some(4) } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [9] = Literal(F32(0.5)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [10] = Binary { op: Multiply, left: [9], right: [8] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [11] = Compose { ty: [3], components: [[4], [10]] } : Handle([3])
DEBUG Resolving [12] = GlobalVariable([6]) : Value(Pointer { base: [29], space: Storage { access: StorageAccess(LOAD) } })
DEBUG Resolving [13] = Access { base: [12], index: [1] } : Value(Pointer { base: [28], space: Storage { access: StorageAccess(LOAD) } })
DEBUG Resolving [14] = Load { pointer: [13] } : Handle([28])
DEBUG Resolving [15] = LocalVariable([0]) : Value(Pointer { base: [28], space: Function })
DEBUG Resolving [16] = Literal(AbstractFloat(3.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [17] = AccessIndex { base: [15], index: 1 } : Value(Pointer { base: [0], space: Function })
DEBUG Resolving [18] = Load { pointer: [17] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [19] = Literal(F32(3.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [20] = Binary { op: Multiply, left: [19], right: [18] } : Handle([0])
DEBUG Resolving [21] = AccessIndex { base: [15], index: 2 } : Value(Pointer { base: [8], space: Function })
DEBUG Resolving [22] = AccessIndex { base: [21], index: 0 } : Value(Pointer { base: [3], space: Function })
DEBUG Resolving [23] = Splat { size: Bi, value: [20] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [24] = Load { pointer: [22] } : Handle([3])
DEBUG Resolving [25] = Binary { op: Subtract, left: [24], right: [23] } : Handle([3])
DEBUG Resolving [26] = AccessIndex { base: [15], index: 2 } : Value(Pointer { base: [8], space: Function })
DEBUG Resolving [27] = AccessIndex { base: [26], index: 1 } : Value(Pointer { base: [3], space: Function })
DEBUG Resolving [28] = Literal(AbstractFloat(2.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [29] = Splat { size: Bi, value: [20] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [30] = Literal(F32(2.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [31] = Binary { op: Multiply, left: [30], right: [29] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [32] = Load { pointer: [27] } : Handle([3])
DEBUG Resolving [33] = Binary { op: Add, left: [32], right: [31] } : Handle([3])
DEBUG Resolving [34] = ZeroValue([30]) : Handle([30])
DEBUG Resolving [35] = LocalVariable([1]) : Value(Pointer { base: [30], space: Function })
DEBUG Resolving [36] = AccessIndex { base: [35], index: 0 } : Value(Pointer { base: [2], space: Function })
DEBUG Resolving [37] = AccessIndex { base: [15], index: 2 } : Value(Pointer { base: [8], space: Function })
DEBUG Resolving [38] = Load { pointer: [37] } : Handle([8])
DEBUG Resolving [39] = CallResult([6]) : Handle([2])
DEBUG Resolving [40] = AccessIndex { base: [35], index: 1 } : Value(Pointer { base: [2], space: Function })
DEBUG Resolving [41] = AccessIndex { base: [15], index: 5 } : Value(Pointer { base: [11], space: Function })
DEBUG Resolving [42] = Load { pointer: [41] } : Handle([11])
DEBUG Resolving [43] = CallResult([17]) : Handle([2])
DEBUG Resolving [44] = AccessIndex { base: [35], index: 2 } : Value(Pointer { base: [4], space: Function })
DEBUG Resolving [45] = AccessIndex { base: [35], index: 3 } : Value(Pointer { base: [2], space: Function })
DEBUG Resolving [46] = AccessIndex { base: [15], index: 2 } : Value(Pointer { base: [8], space: Function })
DEBUG Resolving [47] = Load { pointer: [46] } : Handle([8])
DEBUG Resolving [48] = AccessIndex { base: [15], index: 4 } : Value(Pointer { base: [8], space: Function })
DEBUG Resolving [49] = Load { pointer: [48] } : Handle([8])
DEBUG Resolving [50] = CallResult([10]) : Handle([2])
DEBUG Resolving [51] = Load { pointer: [35] } : Handle([30])
DEBUG Resolving [32] = Literal(I32(3)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [33] = Literal(AbstractInt(0)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [0] = FunctionArgument(0) : Handle([30])
DEBUG Resolving [1] = AccessIndex { base: [0], index: 3 } : Handle([2])
DEBUG Resolving [2] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [3] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [4] = Splat { size: Quad, value: [3] } : Value(Vector { size: Quad, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec4<f32>, vec4<f32>
DEBUG consensus: f32
DEBUG Resolving [5] = Binary { op: Less, left: [1], right: [4] } : Value(Vector { size: Quad, scalar: Scalar { kind: Bool, width: 1 } })
DEBUG Resolving [6] = Relational { fun: Any, argument: [5] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [7] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [8] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [9] = Splat { size: Quad, value: [8] } : Value(Vector { size: Quad, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [10] = GlobalVariable([6]) : Value(Pointer { base: [29], space: Storage { access: StorageAccess(LOAD) } })
DEBUG Resolving [11] = AccessIndex { base: [0], index: 2 } : Handle([4])
DEBUG Resolving [12] = Access { base: [10], index: [11] } : Value(Pointer { base: [28], space: Storage { access: StorageAccess(LOAD) } })
DEBUG Resolving [13] = Load { pointer: [12] } : Handle([28])
DEBUG Resolving [14] = AccessIndex { base: [13], index: 2 } : Handle([8])
DEBUG Resolving [15] = AccessIndex { base: [14], index: 1 } : Handle([3])
DEBUG Resolving [16] = Literal(AbstractFloat(2.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [17] = Splat { size: Bi, value: [16] } : Value(Vector { size: Bi, scalar: Scalar { kind: AbstractFloat, width: 8 } })
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<{AbstractFloat}>
DEBUG consensus: f32
DEBUG Resolving [18] = Literal(F32(2.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [19] = Splat { size: Bi, value: [18] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [20] = Binary { op: Divide, left: [15], right: [19] } : Handle([3])
DEBUG Resolving [21] = AccessIndex { base: [13], index: 2 } : Handle([8])
DEBUG Resolving [22] = AccessIndex { base: [21], index: 0 } : Handle([3])
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [23] = Binary { op: Add, left: [22], right: [20] } : Handle([3])
DEBUG Resolving [24] = AccessIndex { base: [0], index: 0 } : Handle([2])
DEBUG Resolving [25] = Swizzle { size: Bi, vector: [24], pattern: [X, Y, X, X] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [26] = Binary { op: Subtract, left: [25], right: [23] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [27] = AccessIndex { base: [13], index: 3 } : Handle([9])
DEBUG Resolving [28] = CallResult([24]) : Handle([0])
DEBUG Resolving [29] = AccessIndex { base: [26], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [30] = AccessIndex { base: [20], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [31] = Binary { op: Subtract, left: [29], right: [30] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [32] = AccessIndex { base: [26], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [33] = AccessIndex { base: [20], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [34] = Binary { op: Add, left: [32], right: [33] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [35] = Literal(AbstractFloat(3.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [36] = Literal(AbstractFloat(-3.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [37] = AccessIndex { base: [13], index: 1 } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [38] = Literal(F32(-3.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [39] = Binary { op: Multiply, left: [38], right: [37] } : Handle([0])
DEBUG Initial overloads: List {
rules: [
({AbstractInt}, {AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32, i32) -> i32,
(i64, i64, i64) -> i64,
(u32, u32, u32) -> u32,
(u64, u64, u64) -> u64,
(f32, f32, f32) -> f32,
(f16, f16, f16) -> f16,
(f64, f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 1 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 2 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Clamp, List {
rules: [
({AbstractInt}, {AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32, i32) -> i32,
(i64, i64, i64) -> i64,
(u32, u32, u32) -> u32,
(u64, u64, u64) -> u64,
(f32, f32, f32) -> f32,
(f16, f16, f16) -> f16,
(f64, f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [40] = Math { fun: Clamp, arg: [39], arg1: Some([31]), arg2: Some([34]), arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [41] = Literal(AbstractFloat(3.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [42] = AccessIndex { base: [13], index: 1 } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [43] = Literal(F32(3.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [44] = Binary { op: Multiply, left: [43], right: [42] } : Handle([0])
DEBUG Initial overloads: List {
rules: [
({AbstractInt}, {AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32, i32) -> i32,
(i64, i64, i64) -> i64,
(u32, u32, u32) -> u32,
(u64, u64, u64) -> u64,
(f32, f32, f32) -> f32,
(f16, f16, f16) -> f16,
(f64, f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 1 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 2 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Clamp, List {
rules: [
({AbstractInt}, {AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32, i32) -> i32,
(i64, i64, i64) -> i64,
(u32, u32, u32) -> u32,
(u64, u64, u64) -> u64,
(f32, f32, f32) -> f32,
(f16, f16, f16) -> f16,
(f64, f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [45] = Math { fun: Clamp, arg: [44], arg1: Some([31]), arg2: Some([34]), arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [46] = Binary { op: Subtract, left: [45], right: [40] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [47] = Literal(AbstractFloat(4.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [48] = Literal(F32(4.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [49] = Binary { op: Divide, left: [46], right: [48] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [50] = Literal(AbstractFloat(0.5)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [51] = Literal(F32(0.5)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [52] = Binary { op: Multiply, left: [49], right: [51] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [53] = Binary { op: Add, left: [40], right: [52] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [54] = LocalVariable([0]) : Value(Pointer { base: [0], space: Function })
DEBUG Resolving [55] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [56] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [57] = LocalVariable([1]) : Value(Pointer { base: [0], space: Function })
DEBUG Resolving [58] = Literal(AbstractInt(0)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [59] = Literal(I32(0)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [60] = LocalVariable([2]) : Value(Pointer { base: [16], space: Function })
DEBUG Resolving [61] = Load { pointer: [60] } : Handle([16])
DEBUG Resolving [62] = Literal(AbstractInt(4)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: i32, {AbstractInt}
DEBUG consensus: i32
DEBUG Resolving [63] = Literal(I32(4)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [64] = Binary { op: Less, left: [61], right: [63] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [65] = AccessIndex { base: [26], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [66] = AccessIndex { base: [26], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [67] = Load { pointer: [54] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [68] = Binary { op: Subtract, left: [66], right: [67] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [69] = AccessIndex { base: [13], index: 1 } : Handle([0])
DEBUG Resolving [70] = CallResult([23]) : Handle([0])
DEBUG Resolving [71] = Load { pointer: [54] } : Handle([0])
DEBUG Resolving [72] = AccessIndex { base: [13], index: 1 } : Handle([0])
DEBUG Resolving [73] = CallResult([21]) : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [74] = Binary { op: Multiply, left: [70], right: [73] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [75] = Binary { op: Multiply, left: [74], right: [49] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [76] = Load { pointer: [57] } : Handle([0])
DEBUG Resolving [77] = Binary { op: Add, left: [76], right: [75] } : Handle([0])
DEBUG Resolving [78] = Load { pointer: [54] } : Handle([0])
DEBUG Resolving [79] = Binary { op: Add, left: [78], right: [49] } : Handle([0])
DEBUG Resolving [80] = Literal(AbstractInt(1)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [81] = Literal(I32(1)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [82] = Load { pointer: [60] } : Handle([16])
DEBUG Resolving [83] = Binary { op: Add, left: [82], right: [81] } : Handle([16])
DEBUG Resolving [84] = AccessIndex { base: [0], index: 1 } : Handle([2])
DEBUG Resolving [85] = Load { pointer: [57] } : Handle([0])
DEBUG Resolving [86] = CallResult([27]) : Handle([2])
DEBUG Resolving [34] = Literal(I32(0)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [35] = Literal(AbstractInt(0)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [36] = Literal(I32(0)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [37] = Literal(AbstractInt(1)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [38] = Literal(I32(1)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [39] = Literal(AbstractInt(3)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [0] = FunctionArgument(0) : Handle([4])
DEBUG Resolving [1] = GlobalVariable([7]) : Value(Pointer { base: [32], space: Storage { access: StorageAccess(LOAD) } })
DEBUG Resolving [2] = Access { base: [1], index: [0] } : Value(Pointer { base: [31], space: Storage { access: StorageAccess(LOAD) } })
DEBUG Resolving [3] = Load { pointer: [2] } : Handle([31])
DEBUG Resolving [4] = ZeroValue([33]) : Handle([33])
DEBUG Resolving [5] = LocalVariable([0]) : Value(Pointer { base: [33], space: Function })
DEBUG Resolving [6] = AccessIndex { base: [5], index: 0 } : Value(Pointer { base: [2], space: Function })
DEBUG Resolving [7] = AccessIndex { base: [3], index: 0 } : Handle([3])
DEBUG Resolving [8] = CallResult([5]) : Handle([2])
DEBUG Resolving [9] = AccessIndex { base: [5], index: 1 } : Value(Pointer { base: [3], space: Function })
DEBUG Resolving [10] = AccessIndex { base: [3], index: 1 } : Handle([3])
DEBUG Resolving [11] = AccessIndex { base: [5], index: 2 } : Value(Pointer { base: [4], space: Function })
DEBUG Resolving [12] = AccessIndex { base: [5], index: 3 } : Value(Pointer { base: [2], space: Function })
DEBUG Resolving [13] = AccessIndex { base: [3], index: 0 } : Handle([3])
DEBUG Resolving [14] = AccessIndex { base: [3], index: 3 } : Handle([8])
DEBUG Resolving [15] = CallResult([9]) : Handle([2])
DEBUG Resolving [16] = Load { pointer: [5] } : Handle([33])
DEBUG Resolving [40] = Literal(I32(3)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [41] = Literal(AbstractInt(0)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [0] = FunctionArgument(0) : Handle([33])
DEBUG Resolving [1] = AccessIndex { base: [0], index: 1 } : Handle([3])
DEBUG Resolving [2] = Derivative { axis: X, ctrl: None, expr: [1] } : Handle([3])
DEBUG Resolving [3] = AccessIndex { base: [0], index: 1 } : Handle([3])
DEBUG Resolving [4] = Derivative { axis: Y, ctrl: None, expr: [3] } : Handle([3])
DEBUG Resolving [5] = AccessIndex { base: [0], index: 3 } : Handle([2])
DEBUG Resolving [6] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [7] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [8] = Splat { size: Quad, value: [7] } : Value(Vector { size: Quad, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec4<f32>, vec4<f32>
DEBUG consensus: f32
DEBUG Resolving [9] = Binary { op: Less, left: [5], right: [8] } : Value(Vector { size: Quad, scalar: Scalar { kind: Bool, width: 1 } })
DEBUG Resolving [10] = Relational { fun: Any, argument: [9] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [11] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [12] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [13] = Splat { size: Quad, value: [12] } : Value(Vector { size: Quad, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [14] = GlobalVariable([7]) : Value(Pointer { base: [32], space: Storage { access: StorageAccess(LOAD) } })
DEBUG Resolving [15] = AccessIndex { base: [0], index: 2 } : Handle([4])
DEBUG Resolving [16] = Access { base: [14], index: [15] } : Value(Pointer { base: [31], space: Storage { access: StorageAccess(LOAD) } })
DEBUG Resolving [17] = Load { pointer: [16] } : Handle([31])
DEBUG Resolving [18] = AccessIndex { base: [17], index: 2 } : Handle([14])
DEBUG Resolving [19] = AccessIndex { base: [17], index: 3 } : Handle([8])
DEBUG Resolving [20] = LocalVariable([0]) : Value(Pointer { base: [0], space: Function })
DEBUG Resolving [21] = AccessIndex { base: [2], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [22] = AccessIndex { base: [4], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [23] = Compose { ty: [3], components: [[21], [22]] } : Handle([3])
DEBUG Initial overloads: List {
rules: [
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<f32>) -> f32,
(vec2<f16>) -> f16,
(vec2<f64>) -> f64,
(vec3<f32>) -> f32,
(vec3<f16>) -> f16,
(vec3<f64>) -> f64,
(vec4<f32>) -> f32,
(vec4<f16>) -> f16,
(vec4<f64>) -> f64,
],
conclude: Scalar,
}
DEBUG Supplying argument 0 of type vec2<f32>
DEBUG Remaining overloads: List {
rules: [
(vec2<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG initial overloads for Length, List {
rules: [
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<f32>) -> f32,
(vec2<f16>) -> f16,
(vec2<f64>) -> f64,
(vec3<f32>) -> f32,
(vec3<f16>) -> f16,
(vec3<f64>) -> f64,
(vec4<f32>) -> f32,
(vec4<f16>) -> f16,
(vec4<f64>) -> f64,
],
conclude: Scalar,
}
DEBUG overloads after arg 0 of type vec2<f32>: List {
rules: [
(vec2<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG Resolving [24] = Math { fun: Length, arg: [23], arg1: None, arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [25] = Literal(AbstractFloat(0.001)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [26] = Literal(F32(0.001)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [27] = Binary { op: Less, left: [24], right: [26] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [28] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [29] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [30] = Literal(AbstractFloat(2.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [31] = AccessIndex { base: [0], index: 1 } : Handle([3])
DEBUG Resolving [32] = Swizzle { size: Bi, vector: [31], pattern: [X, X, X, X] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [33] = Literal(F32(2.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [34] = Binary { op: Multiply, left: [33], right: [32] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [35] = AccessIndex { base: [2], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [36] = AccessIndex { base: [4], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [37] = Compose { ty: [3], components: [[35], [36]] } : Handle([3])
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [38] = Binary { op: Multiply, left: [34], right: [37] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [39] = AccessIndex { base: [2], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [40] = AccessIndex { base: [4], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [41] = Compose { ty: [3], components: [[39], [40]] } : Handle([3])
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [42] = Binary { op: Subtract, left: [38], right: [41] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [43] = AccessIndex { base: [0], index: 1 } : Handle([3])
DEBUG Resolving [44] = AccessIndex { base: [43], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [45] = AccessIndex { base: [0], index: 1 } : Handle([3])
DEBUG Resolving [46] = AccessIndex { base: [45], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [47] = Binary { op: Multiply, left: [44], right: [46] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [48] = AccessIndex { base: [0], index: 1 } : Handle([3])
DEBUG Resolving [49] = AccessIndex { base: [48], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [50] = Binary { op: Subtract, left: [47], right: [49] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Initial overloads: List {
rules: [
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<f32>) -> f32,
(vec2<f16>) -> f16,
(vec2<f64>) -> f64,
(vec3<f32>) -> f32,
(vec3<f16>) -> f16,
(vec3<f64>) -> f64,
(vec4<f32>) -> f32,
(vec4<f16>) -> f16,
(vec4<f64>) -> f64,
],
conclude: Scalar,
}
DEBUG Supplying argument 0 of type vec2<f32>
DEBUG Remaining overloads: List {
rules: [
(vec2<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG initial overloads for Length, List {
rules: [
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<f32>) -> f32,
(vec2<f16>) -> f16,
(vec2<f64>) -> f64,
(vec3<f32>) -> f32,
(vec3<f16>) -> f16,
(vec3<f64>) -> f64,
(vec4<f32>) -> f32,
(vec4<f16>) -> f16,
(vec4<f64>) -> f64,
],
conclude: Scalar,
}
DEBUG overloads after arg 0 of type vec2<f32>: List {
rules: [
(vec2<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG Resolving [51] = Math { fun: Length, arg: [42], arg1: None, arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [52] = Binary { op: Divide, left: [50], right: [51] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [53] = Literal(AbstractFloat(0.5)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [54] = Literal(F32(0.5)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [55] = Binary { op: Subtract, left: [54], right: [52] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Saturate, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [56] = Math { fun: Saturate, arg: [55], arg1: None, arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [57] = AccessIndex { base: [18], index: 0 } : Handle([4])
DEBUG Resolving [58] = AccessIndex { base: [18], index: 1 } : Handle([4])
DEBUG Resolving [59] = AccessIndex { base: [18], index: 2 } : Handle([11])
DEBUG Resolving [60] = AccessIndex { base: [18], index: 4 } : Handle([13])
DEBUG Resolving [61] = CallResult([28]) : Handle([24])
DEBUG Resolving [62] = AccessIndex { base: [0], index: 0 } : Handle([2])
DEBUG Resolving [63] = Swizzle { size: Bi, vector: [62], pattern: [X, Y, X, X] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [64] = AccessIndex { base: [61], index: 0 } : Handle([2])
DEBUG Resolving [65] = AccessIndex { base: [61], index: 1 } : Handle([2])
DEBUG Resolving [66] = AccessIndex { base: [61], index: 2 } : Handle([2])
DEBUG Resolving [67] = CallResult([29]) : Handle([2])
DEBUG Resolving [68] = Swizzle { size: Tri, vector: [67], pattern: [X, Y, Z, X] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [69] = AccessIndex { base: [67], index: 3 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: vec3<f32>, f32
DEBUG consensus: f32
DEBUG Resolving [70] = Binary { op: Multiply, left: [68], right: [69] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [71] = Load { pointer: [20] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: vec3<f32>, f32
DEBUG consensus: f32
DEBUG Resolving [72] = Binary { op: Multiply, left: [70], right: [71] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [73] = AccessIndex { base: [67], index: 3 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [74] = Load { pointer: [20] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [75] = Binary { op: Multiply, left: [73], right: [74] } : Handle([0])
DEBUG Resolving [76] = Compose { ty: [2], components: [[72], [75]] } : Handle([2])
DEBUG Resolving [42] = Literal(I32(0)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [43] = Literal(AbstractInt(0)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [0] = FunctionArgument(0) : Handle([4])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([4])
DEBUG Resolving [2] = Literal(U32(1)) : Value(Scalar(Scalar { kind: Uint, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: u32, u32
DEBUG consensus: u32
DEBUG Resolving [3] = Binary { op: And, left: [0], right: [2] } : Handle([4])
DEBUG Resolving [4] = As { expr: [3], kind: Float, convert: Some(4) } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [5] = Literal(AbstractFloat(0.5)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [6] = Literal(U32(2)) : Value(Scalar(Scalar { kind: Uint, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: u32, u32
DEBUG consensus: u32
DEBUG Resolving [7] = Binary { op: And, left: [0], right: [6] } : Handle([4])
DEBUG Resolving [8] = As { expr: [7], kind: Float, convert: Some(4) } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [9] = Literal(F32(0.5)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [10] = Binary { op: Multiply, left: [9], right: [8] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [11] = Compose { ty: [3], components: [[4], [10]] } : Handle([3])
DEBUG Resolving [12] = GlobalVariable([8]) : Value(Pointer { base: [35], space: Storage { access: StorageAccess(LOAD) } })
DEBUG Resolving [13] = Access { base: [12], index: [1] } : Value(Pointer { base: [34], space: Storage { access: StorageAccess(LOAD) } })
DEBUG Resolving [14] = Load { pointer: [13] } : Handle([34])
DEBUG Resolving [15] = AccessIndex { base: [14], index: 0 } : Handle([8])
DEBUG Resolving [16] = CallResult([6]) : Handle([2])
DEBUG Resolving [17] = AccessIndex { base: [14], index: 0 } : Handle([8])
DEBUG Resolving [18] = AccessIndex { base: [17], index: 0 } : Handle([3])
DEBUG Resolving [19] = AccessIndex { base: [14], index: 0 } : Handle([8])
DEBUG Resolving [20] = AccessIndex { base: [19], index: 1 } : Handle([3])
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [21] = Binary { op: Multiply, left: [11], right: [20] } : Handle([3])
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [22] = Binary { op: Add, left: [18], right: [21] } : Handle([3])
DEBUG Resolving [23] = GlobalVariable([0]) : Value(Pointer { base: [5], space: Uniform })
DEBUG Resolving [24] = AccessIndex { base: [23], index: 0 } : Value(Pointer { base: [3], space: Uniform })
DEBUG Resolving [25] = Load { pointer: [24] } : Handle([3])
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [26] = Binary { op: Divide, left: [22], right: [25] } : Handle([3])
DEBUG Resolving [27] = ZeroValue([36]) : Handle([36])
DEBUG Resolving [28] = LocalVariable([0]) : Value(Pointer { base: [36], space: Function })
DEBUG Resolving [29] = AccessIndex { base: [28], index: 0 } : Value(Pointer { base: [2], space: Function })
DEBUG Resolving [30] = AccessIndex { base: [28], index: 1 } : Value(Pointer { base: [3], space: Function })
DEBUG Resolving [31] = Load { pointer: [28] } : Handle([36])
DEBUG Resolving [44] = Literal(I32(0)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [45] = Literal(AbstractInt(0)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [0] = FunctionArgument(0) : Handle([36])
DEBUG Resolving [1] = GlobalVariable([3]) : Handle([6])
DEBUG Resolving [2] = GlobalVariable([4]) : Handle([7])
DEBUG Resolving [3] = AccessIndex { base: [0], index: 1 } : Handle([3])
DEBUG Resolving [4] = ImageSample { image: [1], sampler: [2], gather: None, coordinate: [3], array_index: None, offset: None, level: Auto, depth_ref: None } : Value(Vector { size: Quad, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [46] = Literal(I32(0)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [47] = Literal(AbstractInt(0)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [48] = Literal(I32(0)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [49] = Literal(AbstractInt(1)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [50] = Literal(I32(1)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [51] = Literal(AbstractInt(3)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [0] = FunctionArgument(0) : Handle([4])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([4])
DEBUG Resolving [2] = Literal(U32(1)) : Value(Scalar(Scalar { kind: Uint, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: u32, u32
DEBUG consensus: u32
DEBUG Resolving [3] = Binary { op: And, left: [0], right: [2] } : Handle([4])
DEBUG Resolving [4] = As { expr: [3], kind: Float, convert: Some(4) } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [5] = Literal(AbstractFloat(0.5)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [6] = Literal(U32(2)) : Value(Scalar(Scalar { kind: Uint, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: u32, u32
DEBUG consensus: u32
DEBUG Resolving [7] = Binary { op: And, left: [0], right: [6] } : Handle([4])
DEBUG Resolving [8] = As { expr: [7], kind: Float, convert: Some(4) } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [9] = Literal(F32(0.5)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [10] = Binary { op: Multiply, left: [9], right: [8] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [11] = Compose { ty: [3], components: [[4], [10]] } : Handle([3])
DEBUG Resolving [12] = GlobalVariable([9]) : Value(Pointer { base: [38], space: Storage { access: StorageAccess(LOAD) } })
DEBUG Resolving [13] = Access { base: [12], index: [1] } : Value(Pointer { base: [37], space: Storage { access: StorageAccess(LOAD) } })
DEBUG Resolving [14] = Load { pointer: [13] } : Handle([37])
DEBUG Resolving [15] = ZeroValue([39]) : Handle([39])
DEBUG Resolving [16] = LocalVariable([0]) : Value(Pointer { base: [39], space: Function })
DEBUG Resolving [17] = AccessIndex { base: [16], index: 0 } : Value(Pointer { base: [2], space: Function })
DEBUG Resolving [18] = AccessIndex { base: [14], index: 2 } : Handle([8])
DEBUG Resolving [19] = CallResult([6]) : Handle([2])
DEBUG Resolving [20] = AccessIndex { base: [16], index: 1 } : Value(Pointer { base: [2], space: Function })
DEBUG Resolving [21] = AccessIndex { base: [14], index: 4 } : Handle([11])
DEBUG Resolving [22] = CallResult([17]) : Handle([2])
DEBUG Resolving [23] = AccessIndex { base: [16], index: 2 } : Value(Pointer { base: [4], space: Function })
DEBUG Resolving [24] = AccessIndex { base: [16], index: 3 } : Value(Pointer { base: [2], space: Function })
DEBUG Resolving [25] = AccessIndex { base: [14], index: 2 } : Handle([8])
DEBUG Resolving [26] = AccessIndex { base: [14], index: 3 } : Handle([8])
DEBUG Resolving [27] = CallResult([10]) : Handle([2])
DEBUG Resolving [28] = Load { pointer: [16] } : Handle([39])
DEBUG Resolving [52] = Literal(I32(3)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [53] = Literal(AbstractInt(0)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [0] = FunctionArgument(0) : Handle([39])
DEBUG Resolving [1] = Literal(AbstractFloat(2.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [2] = Literal(F32(2.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [3] = Literal(AbstractFloat(0.8)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [4] = Literal(F32(0.8)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [5] = AccessIndex { base: [0], index: 3 } : Handle([2])
DEBUG Resolving [6] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [7] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [8] = Splat { size: Quad, value: [7] } : Value(Vector { size: Quad, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec4<f32>, vec4<f32>
DEBUG consensus: f32
DEBUG Resolving [9] = Binary { op: Less, left: [5], right: [8] } : Value(Vector { size: Quad, scalar: Scalar { kind: Bool, width: 1 } })
DEBUG Resolving [10] = Relational { fun: Any, argument: [9] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [11] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [12] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [13] = Splat { size: Quad, value: [12] } : Value(Vector { size: Quad, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [14] = GlobalVariable([9]) : Value(Pointer { base: [38], space: Storage { access: StorageAccess(LOAD) } })
DEBUG Resolving [15] = AccessIndex { base: [0], index: 2 } : Handle([4])
DEBUG Resolving [16] = Access { base: [14], index: [15] } : Value(Pointer { base: [37], space: Storage { access: StorageAccess(LOAD) } })
DEBUG Resolving [17] = Load { pointer: [16] } : Handle([37])
DEBUG Resolving [18] = AccessIndex { base: [17], index: 6 } : Handle([4])
DEBUG Resolving [19] = Literal(U32(255)) : Value(Scalar(Scalar { kind: Uint, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: u32, u32
DEBUG consensus: u32
DEBUG Resolving [20] = Binary { op: And, left: [18], right: [19] } : Handle([4])
DEBUG Resolving [21] = Literal(U32(0)) : Value(Scalar(Scalar { kind: Uint, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: u32, u32
DEBUG consensus: u32
DEBUG Resolving [22] = Binary { op: Equal, left: [20], right: [21] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [23] = AccessIndex { base: [0], index: 1 } : Handle([2])
DEBUG Resolving [24] = AccessIndex { base: [0], index: 1 } : Handle([2])
DEBUG Resolving [25] = AccessIndex { base: [24], index: 3 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [26] = CallResult([27]) : Handle([2])
DEBUG Resolving [27] = AccessIndex { base: [17], index: 5 } : Handle([0])
DEBUG Resolving [28] = Literal(AbstractFloat(0.5)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [29] = Literal(F32(0.5)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [30] = Binary { op: Multiply, left: [27], right: [29] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [31] = AccessIndex { base: [0], index: 0 } : Handle([2])
DEBUG Resolving [32] = Swizzle { size: Bi, vector: [31], pattern: [X, Y, X, X] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [33] = AccessIndex { base: [17], index: 2 } : Handle([8])
DEBUG Resolving [34] = AccessIndex { base: [33], index: 0 } : Handle([3])
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [35] = Binary { op: Subtract, left: [32], right: [34] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [36] = AccessIndex { base: [17], index: 2 } : Handle([8])
DEBUG Resolving [37] = AccessIndex { base: [36], index: 1 } : Handle([3])
DEBUG Resolving [38] = AccessIndex { base: [37], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [39] = Splat { size: Bi, value: [38] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [40] = Binary { op: Divide, left: [35], right: [39] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [41] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [42] = Literal(AbstractFloat(0.5)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [43] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [44] = Literal(F32(0.5)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [45] = Compose { ty: [3], components: [[43], [44]] } : Handle([3])
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [46] = Binary { op: Subtract, left: [40], right: [45] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [47] = Constant([0]) : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [48] = Literal(F32(3.1415925)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [49] = Literal(F32(6.283185)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [50] = AccessIndex { base: [17], index: 5 } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [51] = Binary { op: Multiply, left: [49], right: [50] } : Handle([0])
DEBUG Resolving [52] = AccessIndex { base: [17], index: 2 } : Handle([8])
DEBUG Resolving [53] = AccessIndex { base: [52], index: 1 } : Handle([3])
DEBUG Resolving [54] = AccessIndex { base: [53], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [55] = Binary { op: Divide, left: [51], right: [54] } : Handle([0])
DEBUG Resolving [56] = AccessIndex { base: [17], index: 5 } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [57] = Binary { op: Multiply, left: [56], right: [4] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [58] = AccessIndex { base: [17], index: 2 } : Handle([8])
DEBUG Resolving [59] = AccessIndex { base: [58], index: 1 } : Handle([3])
DEBUG Resolving [60] = AccessIndex { base: [59], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [61] = Binary { op: Divide, left: [57], right: [60] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [62] = AccessIndex { base: [46], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [63] = Binary { op: Multiply, left: [62], right: [55] } : Handle([0])
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Sin, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [64] = Math { fun: Sin, arg: [63], arg1: None, arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [65] = Binary { op: Multiply, left: [64], right: [61] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [66] = AccessIndex { base: [46], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [67] = Binary { op: Multiply, left: [66], right: [55] } : Handle([0])
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Cos, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [68] = Math { fun: Cos, arg: [67], arg1: None, arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [69] = Binary { op: Multiply, left: [68], right: [61] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [70] = Binary { op: Multiply, left: [69], right: [55] } : Handle([0])
DEBUG Resolving [71] = AccessIndex { base: [46], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [72] = Binary { op: Subtract, left: [71], right: [65] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [73] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [74] = Binary { op: Multiply, left: [70], right: [70] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [75] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [76] = Binary { op: Add, left: [75], right: [74] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Sqrt, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [77] = Math { fun: Sqrt, arg: [76], arg1: None, arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [78] = Binary { op: Divide, left: [72], right: [77] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [79] = AccessIndex { base: [17], index: 2 } : Handle([8])
DEBUG Resolving [80] = AccessIndex { base: [79], index: 1 } : Handle([3])
DEBUG Resolving [81] = AccessIndex { base: [80], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [82] = Binary { op: Multiply, left: [78], right: [81] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [83] = Binary { op: Subtract, left: [82], right: [30] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [84] = Binary { op: Add, left: [82], right: [30] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [85] = Literal(AbstractFloat(0.5)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [86] = Unary { op: Negate, expr: [84] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Initial overloads: List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 1 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Max, List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [87] = Math { fun: Max, arg: [86], arg1: Some([83]), arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [88] = Literal(F32(0.5)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [89] = Binary { op: Subtract, left: [88], right: [87] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Saturate, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [90] = Math { fun: Saturate, arg: [89], arg1: None, arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [91] = AccessIndex { base: [0], index: 1 } : Handle([2])
DEBUG Resolving [92] = AccessIndex { base: [0], index: 1 } : Handle([2])
DEBUG Resolving [93] = AccessIndex { base: [92], index: 3 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [94] = Binary { op: Multiply, left: [90], right: [93] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [95] = CallResult([27]) : Handle([2])
DEBUG Resolving [54] = Literal(I32(0)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [55] = Literal(AbstractInt(0)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [56] = Literal(I32(0)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [57] = Literal(AbstractInt(1)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [58] = Literal(I32(1)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [59] = Literal(AbstractInt(3)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [0] = FunctionArgument(0) : Handle([4])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([4])
DEBUG Resolving [2] = Literal(U32(1)) : Value(Scalar(Scalar { kind: Uint, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: u32, u32
DEBUG consensus: u32
DEBUG Resolving [3] = Binary { op: And, left: [0], right: [2] } : Handle([4])
DEBUG Resolving [4] = As { expr: [3], kind: Float, convert: Some(4) } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [5] = Literal(AbstractFloat(0.5)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [6] = Literal(U32(2)) : Value(Scalar(Scalar { kind: Uint, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: u32, u32
DEBUG consensus: u32
DEBUG Resolving [7] = Binary { op: And, left: [0], right: [6] } : Handle([4])
DEBUG Resolving [8] = As { expr: [7], kind: Float, convert: Some(4) } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [9] = Literal(F32(0.5)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [10] = Binary { op: Multiply, left: [9], right: [8] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [11] = Compose { ty: [3], components: [[4], [10]] } : Handle([3])
DEBUG Resolving [12] = GlobalVariable([10]) : Value(Pointer { base: [41], space: Storage { access: StorageAccess(LOAD) } })
DEBUG Resolving [13] = Access { base: [12], index: [1] } : Value(Pointer { base: [40], space: Storage { access: StorageAccess(LOAD) } })
DEBUG Resolving [14] = Load { pointer: [13] } : Handle([40])
DEBUG Resolving [15] = ZeroValue([42]) : Handle([42])
DEBUG Resolving [16] = LocalVariable([0]) : Value(Pointer { base: [42], space: Function })
DEBUG Resolving [17] = AccessIndex { base: [16], index: 0 } : Value(Pointer { base: [2], space: Function })
DEBUG Resolving [18] = AccessIndex { base: [14], index: 2 } : Handle([8])
DEBUG Resolving [19] = AccessIndex { base: [14], index: 6 } : Handle([21])
DEBUG Resolving [20] = CallResult([7]) : Handle([2])
DEBUG Resolving [21] = AccessIndex { base: [16], index: 1 } : Value(Pointer { base: [3], space: Function })
DEBUG Resolving [22] = AccessIndex { base: [14], index: 5 } : Handle([19])
DEBUG Resolving [23] = CallResult([8]) : Handle([3])
DEBUG Resolving [24] = AccessIndex { base: [16], index: 2 } : Value(Pointer { base: [2], space: Function })
DEBUG Resolving [25] = AccessIndex { base: [14], index: 4 } : Handle([11])
DEBUG Resolving [26] = CallResult([17]) : Handle([2])
DEBUG Resolving [27] = AccessIndex { base: [16], index: 3 } : Value(Pointer { base: [2], space: Function })
DEBUG Resolving [28] = AccessIndex { base: [14], index: 2 } : Handle([8])
DEBUG Resolving [29] = AccessIndex { base: [14], index: 3 } : Handle([8])
DEBUG Resolving [30] = AccessIndex { base: [14], index: 6 } : Handle([21])
DEBUG Resolving [31] = CallResult([11]) : Handle([2])
DEBUG Resolving [32] = Load { pointer: [16] } : Handle([42])
DEBUG Resolving [60] = Literal(I32(3)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [61] = Literal(AbstractInt(0)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [0] = FunctionArgument(0) : Handle([42])
DEBUG Resolving [1] = GlobalVariable([3]) : Handle([6])
DEBUG Resolving [2] = GlobalVariable([4]) : Handle([7])
DEBUG Resolving [3] = AccessIndex { base: [0], index: 1 } : Handle([3])
DEBUG Resolving [4] = ImageSample { image: [1], sampler: [2], gather: None, coordinate: [3], array_index: None, offset: None, level: Auto, depth_ref: None } : Value(Vector { size: Quad, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [5] = AccessIndex { base: [4], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [6] = AccessIndex { base: [0], index: 2 } : Handle([2])
DEBUG Resolving [7] = Swizzle { size: Tri, vector: [6], pattern: [X, Y, Z, X] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [8] = GlobalVariable([2]) : Value(Pointer { base: [0], space: Uniform })
DEBUG Resolving [9] = Load { pointer: [8] } : Handle([0])
DEBUG Resolving [10] = GlobalVariable([1]) : Value(Pointer { base: [2], space: Uniform })
DEBUG Resolving [11] = Load { pointer: [10] } : Handle([2])
DEBUG Resolving [12] = CallResult([4]) : Handle([0])
DEBUG Resolving [13] = AccessIndex { base: [0], index: 3 } : Handle([2])
DEBUG Resolving [14] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [15] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [16] = Splat { size: Quad, value: [15] } : Value(Vector { size: Quad, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec4<f32>, vec4<f32>
DEBUG consensus: f32
DEBUG Resolving [17] = Binary { op: Less, left: [13], right: [16] } : Value(Vector { size: Quad, scalar: Scalar { kind: Bool, width: 1 } })
DEBUG Resolving [18] = Relational { fun: Any, argument: [17] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [19] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [20] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [21] = Splat { size: Quad, value: [20] } : Value(Vector { size: Quad, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [22] = AccessIndex { base: [0], index: 2 } : Handle([2])
DEBUG Resolving [23] = CallResult([27]) : Handle([2])
DEBUG Resolving [62] = Literal(I32(0)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [63] = Literal(AbstractInt(0)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [64] = Literal(I32(0)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [65] = Literal(AbstractInt(1)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [66] = Literal(I32(1)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [67] = Literal(AbstractInt(3)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [0] = FunctionArgument(0) : Handle([4])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([4])
DEBUG Resolving [2] = Literal(U32(1)) : Value(Scalar(Scalar { kind: Uint, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: u32, u32
DEBUG consensus: u32
DEBUG Resolving [3] = Binary { op: And, left: [0], right: [2] } : Handle([4])
DEBUG Resolving [4] = As { expr: [3], kind: Float, convert: Some(4) } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [5] = Literal(AbstractFloat(0.5)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [6] = Literal(U32(2)) : Value(Scalar(Scalar { kind: Uint, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: u32, u32
DEBUG consensus: u32
DEBUG Resolving [7] = Binary { op: And, left: [0], right: [6] } : Handle([4])
DEBUG Resolving [8] = As { expr: [7], kind: Float, convert: Some(4) } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [9] = Literal(F32(0.5)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [10] = Binary { op: Multiply, left: [9], right: [8] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [11] = Compose { ty: [3], components: [[4], [10]] } : Handle([3])
DEBUG Resolving [12] = GlobalVariable([11]) : Value(Pointer { base: [44], space: Storage { access: StorageAccess(LOAD) } })
DEBUG Resolving [13] = Access { base: [12], index: [1] } : Value(Pointer { base: [43], space: Storage { access: StorageAccess(LOAD) } })
DEBUG Resolving [14] = Load { pointer: [13] } : Handle([43])
DEBUG Resolving [15] = ZeroValue([45]) : Handle([45])
DEBUG Resolving [16] = LocalVariable([0]) : Value(Pointer { base: [45], space: Function })
DEBUG Resolving [17] = AccessIndex { base: [16], index: 0 } : Value(Pointer { base: [2], space: Function })
DEBUG Resolving [18] = AccessIndex { base: [14], index: 4 } : Handle([8])
DEBUG Resolving [19] = CallResult([6]) : Handle([2])
DEBUG Resolving [20] = AccessIndex { base: [16], index: 1 } : Value(Pointer { base: [3], space: Function })
DEBUG Resolving [21] = AccessIndex { base: [14], index: 7 } : Handle([19])
DEBUG Resolving [22] = CallResult([8]) : Handle([3])
DEBUG Resolving [23] = AccessIndex { base: [16], index: 2 } : Value(Pointer { base: [4], space: Function })
DEBUG Resolving [24] = AccessIndex { base: [16], index: 3 } : Value(Pointer { base: [2], space: Function })
DEBUG Resolving [25] = AccessIndex { base: [14], index: 4 } : Handle([8])
DEBUG Resolving [26] = AccessIndex { base: [14], index: 5 } : Handle([8])
DEBUG Resolving [27] = CallResult([10]) : Handle([2])
DEBUG Resolving [28] = Load { pointer: [16] } : Handle([45])
DEBUG Resolving [68] = Literal(I32(3)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [69] = Literal(AbstractInt(0)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [0] = FunctionArgument(0) : Handle([45])
DEBUG Resolving [1] = GlobalVariable([3]) : Handle([6])
DEBUG Resolving [2] = GlobalVariable([4]) : Handle([7])
DEBUG Resolving [3] = AccessIndex { base: [0], index: 1 } : Handle([3])
DEBUG Resolving [4] = ImageSample { image: [1], sampler: [2], gather: None, coordinate: [3], array_index: None, offset: None, level: Auto, depth_ref: None } : Value(Vector { size: Quad, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [5] = AccessIndex { base: [0], index: 3 } : Handle([2])
DEBUG Resolving [6] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [7] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [8] = Splat { size: Quad, value: [7] } : Value(Vector { size: Quad, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec4<f32>, vec4<f32>
DEBUG consensus: f32
DEBUG Resolving [9] = Binary { op: Less, left: [5], right: [8] } : Value(Vector { size: Quad, scalar: Scalar { kind: Bool, width: 1 } })
DEBUG Resolving [10] = Relational { fun: Any, argument: [9] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [11] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [12] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [13] = Splat { size: Quad, value: [12] } : Value(Vector { size: Quad, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [14] = GlobalVariable([11]) : Value(Pointer { base: [44], space: Storage { access: StorageAccess(LOAD) } })
DEBUG Resolving [15] = AccessIndex { base: [0], index: 2 } : Handle([4])
DEBUG Resolving [16] = Access { base: [14], index: [15] } : Value(Pointer { base: [43], space: Storage { access: StorageAccess(LOAD) } })
DEBUG Resolving [17] = Load { pointer: [16] } : Handle([43])
DEBUG Resolving [18] = AccessIndex { base: [0], index: 0 } : Handle([2])
DEBUG Resolving [19] = Swizzle { size: Bi, vector: [18], pattern: [X, Y, X, X] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [20] = AccessIndex { base: [17], index: 4 } : Handle([8])
DEBUG Resolving [21] = AccessIndex { base: [17], index: 6 } : Handle([9])
DEBUG Resolving [22] = CallResult([26]) : Handle([0])
DEBUG Resolving [23] = LocalVariable([0]) : Value(Pointer { base: [2], space: Function })
DEBUG Resolving [24] = AccessIndex { base: [17], index: 2 } : Handle([4])
DEBUG Resolving [25] = Literal(U32(255)) : Value(Scalar(Scalar { kind: Uint, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: u32, u32
DEBUG consensus: u32
DEBUG Resolving [26] = Binary { op: And, left: [24], right: [25] } : Handle([4])
DEBUG Resolving [27] = Literal(U32(0)) : Value(Scalar(Scalar { kind: Uint, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: u32, u32
DEBUG consensus: u32
DEBUG Resolving [28] = Binary { op: NotEqual, left: [26], right: [27] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [29] = Load { pointer: [23] } : Handle([2])
DEBUG Resolving [30] = Swizzle { size: Tri, vector: [29], pattern: [X, Y, Z, X] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [31] = Constant([1]) : Handle([1])
DEBUG Initial overloads: List {
rules: [
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> {AbstractInt},
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> {AbstractFloat},
(vec2<i32>, vec2<i32>) -> i32,
(vec2<i64>, vec2<i64>) -> i64,
(vec2<u32>, vec2<u32>) -> u32,
(vec2<u64>, vec2<u64>) -> u64,
(vec2<f32>, vec2<f32>) -> f32,
(vec2<f16>, vec2<f16>) -> f16,
(vec2<f64>, vec2<f64>) -> f64,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> {AbstractInt},
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> {AbstractFloat},
(vec3<i32>, vec3<i32>) -> i32,
(vec3<i64>, vec3<i64>) -> i64,
(vec3<u32>, vec3<u32>) -> u32,
(vec3<u64>, vec3<u64>) -> u64,
(vec3<f32>, vec3<f32>) -> f32,
(vec3<f16>, vec3<f16>) -> f16,
(vec3<f64>, vec3<f64>) -> f64,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> {AbstractInt},
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> {AbstractFloat},
(vec4<i32>, vec4<i32>) -> i32,
(vec4<i64>, vec4<i64>) -> i64,
(vec4<u32>, vec4<u32>) -> u32,
(vec4<u64>, vec4<u64>) -> u64,
(vec4<f32>, vec4<f32>) -> f32,
(vec4<f16>, vec4<f16>) -> f16,
(vec4<f64>, vec4<f64>) -> f64,
],
conclude: Scalar,
}
DEBUG Supplying argument 0 of type vec3<f32>
DEBUG Remaining overloads: List {
rules: [
(vec3<f32>, vec3<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG Supplying argument 1 of type vec3<f32>
DEBUG Remaining overloads: List {
rules: [
(vec3<f32>, vec3<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG initial overloads for Dot, List {
rules: [
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> {AbstractInt},
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> {AbstractFloat},
(vec2<i32>, vec2<i32>) -> i32,
(vec2<i64>, vec2<i64>) -> i64,
(vec2<u32>, vec2<u32>) -> u32,
(vec2<u64>, vec2<u64>) -> u64,
(vec2<f32>, vec2<f32>) -> f32,
(vec2<f16>, vec2<f16>) -> f16,
(vec2<f64>, vec2<f64>) -> f64,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> {AbstractInt},
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> {AbstractFloat},
(vec3<i32>, vec3<i32>) -> i32,
(vec3<i64>, vec3<i64>) -> i64,
(vec3<u32>, vec3<u32>) -> u32,
(vec3<u64>, vec3<u64>) -> u64,
(vec3<f32>, vec3<f32>) -> f32,
(vec3<f16>, vec3<f16>) -> f16,
(vec3<f64>, vec3<f64>) -> f64,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> {AbstractInt},
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> {AbstractFloat},
(vec4<i32>, vec4<i32>) -> i32,
(vec4<i64>, vec4<i64>) -> i64,
(vec4<u32>, vec4<u32>) -> u32,
(vec4<u64>, vec4<u64>) -> u64,
(vec4<f32>, vec4<f32>) -> f32,
(vec4<f16>, vec4<f16>) -> f16,
(vec4<f64>, vec4<f64>) -> f64,
],
conclude: Scalar,
}
DEBUG overloads after arg 0 of type vec3<f32>: List {
rules: [
(vec3<f32>, vec3<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG overloads after arg 1 of type vec3<f32>: List {
rules: [
(vec3<f32>, vec3<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG Resolving [32] = Math { fun: Dot, arg: [30], arg1: Some([31]), arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [33] = Splat { size: Tri, value: [32] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [34] = AccessIndex { base: [4], index: 3 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [35] = Compose { ty: [2], components: [[33], [34]] } : Handle([2])
DEBUG Resolving [36] = Load { pointer: [23] } : Handle([2])
DEBUG Resolving [37] = AccessIndex { base: [17], index: 3 } : Handle([0])
DEBUG Resolving [38] = Literal(AbstractFloat(0.5)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [39] = Literal(F32(0.5)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [40] = Binary { op: Subtract, left: [39], right: [22] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Saturate, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [41] = Math { fun: Saturate, arg: [40], arg1: None, arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [42] = Binary { op: Multiply, left: [37], right: [41] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [43] = CallResult([27]) : Handle([2])
DEBUG Resolving [70] = Literal(I32(0)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [71] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [72] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [73] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [74] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [75] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [76] = Compose { ty: [2], components: [[71], [72], [73], [75]] } : Handle([2])
DEBUG Resolving [77] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [78] = Literal(F32(0.3441)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [79] = Literal(F32(-0.3441)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [80] = Literal(F32(1.772)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [81] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [82] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [83] = Compose { ty: [2], components: [[77], [79], [80], [82]] } : Handle([2])
DEBUG Resolving [84] = Literal(F32(1.402)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [85] = Literal(F32(0.7141)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [86] = Literal(F32(-0.7141)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [87] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [88] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [89] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [90] = Compose { ty: [2], components: [[84], [86], [87], [89]] } : Handle([2])
DEBUG Resolving [91] = Literal(F32(0.701)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [92] = Literal(F32(-0.701)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [93] = Literal(F32(0.5291)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [94] = Literal(F32(0.886)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [95] = Literal(F32(-0.886)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [96] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [97] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [98] = Compose { ty: [2], components: [[92], [93], [95], [97]] } : Handle([2])
DEBUG Resolving [99] = Compose { ty: [47], components: [[76], [83], [90], [98]] } : Handle([47])
DEBUG Resolving [100] = Literal(AbstractInt(0)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [101] = Literal(I32(0)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [102] = Literal(AbstractInt(3)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [0] = FunctionArgument(0) : Handle([4])
DEBUG Resolving [1] = Literal(U32(1)) : Value(Scalar(Scalar { kind: Uint, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: u32, u32
DEBUG consensus: u32
DEBUG Resolving [2] = Binary { op: And, left: [0], right: [1] } : Handle([4])
DEBUG Resolving [3] = As { expr: [2], kind: Float, convert: Some(4) } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [4] = Literal(AbstractFloat(0.5)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [5] = Literal(U32(2)) : Value(Scalar(Scalar { kind: Uint, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: u32, u32
DEBUG consensus: u32
DEBUG Resolving [6] = Binary { op: And, left: [0], right: [5] } : Handle([4])
DEBUG Resolving [7] = As { expr: [6], kind: Float, convert: Some(4) } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [8] = Literal(F32(0.5)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [9] = Binary { op: Multiply, left: [8], right: [7] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [10] = Compose { ty: [3], components: [[3], [9]] } : Handle([3])
DEBUG Resolving [11] = ZeroValue([48]) : Handle([48])
DEBUG Resolving [12] = LocalVariable([0]) : Value(Pointer { base: [48], space: Function })
DEBUG Resolving [13] = AccessIndex { base: [12], index: 0 } : Value(Pointer { base: [2], space: Function })
DEBUG Resolving [14] = GlobalVariable([12]) : Value(Pointer { base: [46], space: Uniform })
DEBUG Resolving [15] = AccessIndex { base: [14], index: 0 } : Value(Pointer { base: [8], space: Uniform })
DEBUG Resolving [16] = Load { pointer: [15] } : Handle([8])
DEBUG Resolving [17] = CallResult([6]) : Handle([2])
DEBUG Resolving [18] = AccessIndex { base: [12], index: 1 } : Value(Pointer { base: [3], space: Function })
DEBUG Resolving [19] = AccessIndex { base: [12], index: 2 } : Value(Pointer { base: [2], space: Function })
DEBUG Resolving [20] = GlobalVariable([12]) : Value(Pointer { base: [46], space: Uniform })
DEBUG Resolving [21] = AccessIndex { base: [20], index: 0 } : Value(Pointer { base: [8], space: Uniform })
DEBUG Resolving [22] = Load { pointer: [21] } : Handle([8])
DEBUG Resolving [23] = GlobalVariable([12]) : Value(Pointer { base: [46], space: Uniform })
DEBUG Resolving [24] = AccessIndex { base: [23], index: 1 } : Value(Pointer { base: [8], space: Uniform })
DEBUG Resolving [25] = Load { pointer: [24] } : Handle([8])
DEBUG Resolving [26] = CallResult([10]) : Handle([2])
DEBUG Resolving [27] = Load { pointer: [12] } : Handle([48])
DEBUG Resolving [103] = Literal(I32(3)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [104] = Literal(AbstractInt(0)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [0] = FunctionArgument(0) : Handle([48])
DEBUG Resolving [1] = AccessIndex { base: [0], index: 2 } : Handle([2])
DEBUG Resolving [2] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [3] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [4] = Splat { size: Quad, value: [3] } : Value(Vector { size: Quad, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec4<f32>, vec4<f32>
DEBUG consensus: f32
DEBUG Resolving [5] = Binary { op: Less, left: [1], right: [4] } : Value(Vector { size: Quad, scalar: Scalar { kind: Bool, width: 1 } })
DEBUG Resolving [6] = Relational { fun: Any, argument: [5] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [7] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [8] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [9] = Splat { size: Quad, value: [8] } : Value(Vector { size: Quad, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [10] = GlobalVariable([13]) : Handle([6])
DEBUG Resolving [11] = GlobalVariable([15]) : Handle([7])
DEBUG Resolving [12] = AccessIndex { base: [0], index: 1 } : Handle([3])
DEBUG Resolving [13] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [14] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [15] = ImageSample { image: [10], sampler: [11], gather: None, coordinate: [12], array_index: None, offset: None, level: Exact([14]), depth_ref: None } : Value(Vector { size: Quad, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [16] = AccessIndex { base: [15], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [17] = GlobalVariable([14]) : Handle([6])
DEBUG Resolving [18] = GlobalVariable([15]) : Handle([7])
DEBUG Resolving [19] = AccessIndex { base: [0], index: 1 } : Handle([3])
DEBUG Resolving [20] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [21] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [22] = ImageSample { image: [17], sampler: [18], gather: None, coordinate: [19], array_index: None, offset: None, level: Exact([21]), depth_ref: None } : Value(Vector { size: Quad, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [23] = Swizzle { size: Bi, vector: [22], pattern: [X, Y, X, X] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [24] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [25] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [26] = Compose { ty: [2], components: [[16], [23], [25]] } : Handle([2])
DEBUG Resolving [27] = Constant([2]) : Handle([47])
DEBUG wgsl automatic_conversion_consensus: mat4x4<f32>, vec4<f32>
DEBUG consensus: f32
DEBUG Resolving [28] = Binary { op: Multiply, left: [27], right: [26] } : Value(Vector { size: Quad, scalar: Scalar { kind: Float, width: 4 } })
DEBUG var GlobalVariable { name: Some("globals"), space: Uniform, binding: None, ty: [5], init: None }
DEBUG var GlobalVariable { name: Some("gamma_ratios"), space: Uniform, binding: None, ty: [2], init: None }
DEBUG var GlobalVariable { name: Some("grayscale_enhanced_contrast"), space: Uniform, binding: None, ty: [0], init: None }
DEBUG var GlobalVariable { name: Some("t_sprite"), space: Handle, binding: None, ty: [6], init: None }
DEBUG var GlobalVariable { name: Some("s_sprite"), space: Handle, binding: None, ty: [7], init: None }
DEBUG var GlobalVariable { name: Some("b_quads"), space: Storage { access: StorageAccess(LOAD) }, binding: None, ty: [24], init: None }
DEBUG var GlobalVariable { name: Some("b_shadows"), space: Storage { access: StorageAccess(LOAD) }, binding: None, ty: [27], init: None }
DEBUG var GlobalVariable { name: Some("b_path_vertices"), space: Storage { access: StorageAccess(LOAD) }, binding: None, ty: [30], init: None }
DEBUG var GlobalVariable { name: Some("b_path_sprites"), space: Storage { access: StorageAccess(LOAD) }, binding: None, ty: [33], init: None }
DEBUG var GlobalVariable { name: Some("b_underlines"), space: Storage { access: StorageAccess(LOAD) }, binding: None, ty: [36], init: None }
DEBUG var GlobalVariable { name: Some("b_mono_sprites"), space: Storage { access: StorageAccess(LOAD) }, binding: None, ty: [39], init: None }
DEBUG var GlobalVariable { name: Some("b_poly_sprites"), space: Storage { access: StorageAccess(LOAD) }, binding: None, ty: [42], init: None }
DEBUG var GlobalVariable { name: Some("surface_locals"), space: Uniform, binding: None, ty: [44], init: None }
DEBUG var GlobalVariable { name: Some("t_y"), space: Handle, binding: None, ty: [6], init: None }
DEBUG var GlobalVariable { name: Some("t_cb_cr"), space: Handle, binding: None, ty: [6], init: None }
DEBUG var GlobalVariable { name: Some("s_surface"), space: Handle, binding: None, ty: [7], init: None }
DEBUG initial overloads for Dot, List {
rules: [
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> {AbstractInt},
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> {AbstractFloat},
(vec2<i32>, vec2<i32>) -> i32,
(vec2<i64>, vec2<i64>) -> i64,
(vec2<u32>, vec2<u32>) -> u32,
(vec2<u64>, vec2<u64>) -> u64,
(vec2<f32>, vec2<f32>) -> f32,
(vec2<f16>, vec2<f16>) -> f16,
(vec2<f64>, vec2<f64>) -> f64,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> {AbstractInt},
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> {AbstractFloat},
(vec3<i32>, vec3<i32>) -> i32,
(vec3<i64>, vec3<i64>) -> i64,
(vec3<u32>, vec3<u32>) -> u32,
(vec3<u64>, vec3<u64>) -> u64,
(vec3<f32>, vec3<f32>) -> f32,
(vec3<f16>, vec3<f16>) -> f16,
(vec3<f64>, vec3<f64>) -> f64,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> {AbstractInt},
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> {AbstractFloat},
(vec4<i32>, vec4<i32>) -> i32,
(vec4<i64>, vec4<i64>) -> i64,
(vec4<u32>, vec4<u32>) -> u32,
(vec4<u64>, vec4<u64>) -> u64,
(vec4<f32>, vec4<f32>) -> f32,
(vec4<f16>, vec4<f16>) -> f16,
(vec4<f64>, vec4<f64>) -> f64,
],
conclude: Scalar,
}
DEBUG overloads after arg 0 of type vec3<f32>: List {
rules: [
(vec3<f32>, vec3<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG overloads after arg 1 of type vec3<f32>: List {
rules: [
(vec3<f32>, vec3<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG initial overloads for Dot: List {
rules: [
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> {AbstractInt},
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> {AbstractFloat},
(vec2<i32>, vec2<i32>) -> i32,
(vec2<i64>, vec2<i64>) -> i64,
(vec2<u32>, vec2<u32>) -> u32,
(vec2<u64>, vec2<u64>) -> u64,
(vec2<f32>, vec2<f32>) -> f32,
(vec2<f16>, vec2<f16>) -> f16,
(vec2<f64>, vec2<f64>) -> f64,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> {AbstractInt},
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> {AbstractFloat},
(vec3<i32>, vec3<i32>) -> i32,
(vec3<i64>, vec3<i64>) -> i64,
(vec3<u32>, vec3<u32>) -> u32,
(vec3<u64>, vec3<u64>) -> u64,
(vec3<f32>, vec3<f32>) -> f32,
(vec3<f16>, vec3<f16>) -> f16,
(vec3<f64>, vec3<f64>) -> f64,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> {AbstractInt},
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> {AbstractFloat},
(vec4<i32>, vec4<i32>) -> i32,
(vec4<i64>, vec4<i64>) -> i64,
(vec4<u32>, vec4<u32>) -> u32,
(vec4<u64>, vec4<u64>) -> u64,
(vec4<f32>, vec4<f32>) -> f32,
(vec4<f16>, vec4<f16>) -> f16,
(vec4<f64>, vec4<f64>) -> f64,
],
conclude: Scalar,
}
DEBUG overloads after arg 0: List {
rules: [
(vec3<f32>, vec3<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG overloads after arg 1: List {
rules: [
(vec3<f32>, vec3<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG initial overloads for Saturate, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Saturate: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Transpose, [
(mat2x2<{AbstractFloat}>) -> mat2x2<{AbstractFloat}>,
(mat2x2<f32>) -> mat2x2<f32>,
(mat2x2<f16>) -> mat2x2<f16>,
(mat2x2<f64>) -> mat2x2<f64>,
(mat2x3<{AbstractFloat}>) -> mat3x2<{AbstractFloat}>,
(mat2x3<f32>) -> mat3x2<f32>,
(mat2x3<f16>) -> mat3x2<f16>,
(mat2x3<f64>) -> mat3x2<f64>,
(mat2x4<{AbstractFloat}>) -> mat4x2<{AbstractFloat}>,
(mat2x4<f32>) -> mat4x2<f32>,
(mat2x4<f16>) -> mat4x2<f16>,
(mat2x4<f64>) -> mat4x2<f64>,
(mat3x2<{AbstractFloat}>) -> mat2x3<{AbstractFloat}>,
(mat3x2<f32>) -> mat2x3<f32>,
(mat3x2<f16>) -> mat2x3<f16>,
(mat3x2<f64>) -> mat2x3<f64>,
(mat3x3<{AbstractFloat}>) -> mat3x3<{AbstractFloat}>,
(mat3x3<f32>) -> mat3x3<f32>,
(mat3x3<f16>) -> mat3x3<f16>,
(mat3x3<f64>) -> mat3x3<f64>,
(mat3x4<{AbstractFloat}>) -> mat4x3<{AbstractFloat}>,
(mat3x4<f32>) -> mat4x3<f32>,
(mat3x4<f16>) -> mat4x3<f16>,
(mat3x4<f64>) -> mat4x3<f64>,
(mat4x2<{AbstractFloat}>) -> mat2x4<{AbstractFloat}>,
(mat4x2<f32>) -> mat2x4<f32>,
(mat4x2<f16>) -> mat2x4<f16>,
(mat4x2<f64>) -> mat2x4<f64>,
(mat4x3<{AbstractFloat}>) -> mat3x4<{AbstractFloat}>,
(mat4x3<f32>) -> mat3x4<f32>,
(mat4x3<f16>) -> mat3x4<f16>,
(mat4x3<f64>) -> mat3x4<f64>,
(mat4x4<{AbstractFloat}>) -> mat4x4<{AbstractFloat}>,
(mat4x4<f32>) -> mat4x4<f32>,
(mat4x4<f16>) -> mat4x4<f16>,
(mat4x4<f64>) -> mat4x4<f64>,
]
DEBUG arg 0 of type mat2x2<f32>
DEBUG considering rule (mat2x2<{AbstractFloat}>) -> mat2x2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat2x2<f32>) -> mat2x2<f32>
DEBUG types are equivalent
DEBUG considering rule (mat2x2<f16>) -> mat2x2<f16>
DEBUG no conversion possible
DEBUG considering rule (mat2x2<f64>) -> mat2x2<f64>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<{AbstractFloat}>) -> mat3x2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<f32>) -> mat3x2<f32>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<f16>) -> mat3x2<f16>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<f64>) -> mat3x2<f64>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<{AbstractFloat}>) -> mat4x2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<f32>) -> mat4x2<f32>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<f16>) -> mat4x2<f16>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<f64>) -> mat4x2<f64>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<{AbstractFloat}>) -> mat2x3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<f32>) -> mat2x3<f32>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<f16>) -> mat2x3<f16>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<f64>) -> mat2x3<f64>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<{AbstractFloat}>) -> mat3x3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<f32>) -> mat3x3<f32>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<f16>) -> mat3x3<f16>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<f64>) -> mat3x3<f64>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<{AbstractFloat}>) -> mat4x3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<f32>) -> mat4x3<f32>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<f16>) -> mat4x3<f16>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<f64>) -> mat4x3<f64>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<{AbstractFloat}>) -> mat2x4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<f32>) -> mat2x4<f32>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<f16>) -> mat2x4<f16>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<f64>) -> mat2x4<f64>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<{AbstractFloat}>) -> mat3x4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<f32>) -> mat3x4<f32>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<f16>) -> mat3x4<f16>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<f64>) -> mat3x4<f64>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<{AbstractFloat}>) -> mat4x4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<f32>) -> mat4x4<f32>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<f16>) -> mat4x4<f16>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<f64>) -> mat4x4<f64>
DEBUG no conversion possible
DEBUG overloads after arg 0 of type mat2x2<f32>: [
(mat2x2<f32>) -> mat2x2<f32>,
]
DEBUG initial overloads for Transpose: [
(mat2x2<{AbstractFloat}>) -> mat2x2<{AbstractFloat}>,
(mat2x2<f32>) -> mat2x2<f32>,
(mat2x2<f16>) -> mat2x2<f16>,
(mat2x2<f64>) -> mat2x2<f64>,
(mat2x3<{AbstractFloat}>) -> mat3x2<{AbstractFloat}>,
(mat2x3<f32>) -> mat3x2<f32>,
(mat2x3<f16>) -> mat3x2<f16>,
(mat2x3<f64>) -> mat3x2<f64>,
(mat2x4<{AbstractFloat}>) -> mat4x2<{AbstractFloat}>,
(mat2x4<f32>) -> mat4x2<f32>,
(mat2x4<f16>) -> mat4x2<f16>,
(mat2x4<f64>) -> mat4x2<f64>,
(mat3x2<{AbstractFloat}>) -> mat2x3<{AbstractFloat}>,
(mat3x2<f32>) -> mat2x3<f32>,
(mat3x2<f16>) -> mat2x3<f16>,
(mat3x2<f64>) -> mat2x3<f64>,
(mat3x3<{AbstractFloat}>) -> mat3x3<{AbstractFloat}>,
(mat3x3<f32>) -> mat3x3<f32>,
(mat3x3<f16>) -> mat3x3<f16>,
(mat3x3<f64>) -> mat3x3<f64>,
(mat3x4<{AbstractFloat}>) -> mat4x3<{AbstractFloat}>,
(mat3x4<f32>) -> mat4x3<f32>,
(mat3x4<f16>) -> mat4x3<f16>,
(mat3x4<f64>) -> mat4x3<f64>,
(mat4x2<{AbstractFloat}>) -> mat2x4<{AbstractFloat}>,
(mat4x2<f32>) -> mat2x4<f32>,
(mat4x2<f16>) -> mat2x4<f16>,
(mat4x2<f64>) -> mat2x4<f64>,
(mat4x3<{AbstractFloat}>) -> mat3x4<{AbstractFloat}>,
(mat4x3<f32>) -> mat3x4<f32>,
(mat4x3<f16>) -> mat3x4<f16>,
(mat4x3<f64>) -> mat3x4<f64>,
(mat4x4<{AbstractFloat}>) -> mat4x4<{AbstractFloat}>,
(mat4x4<f32>) -> mat4x4<f32>,
(mat4x4<f16>) -> mat4x4<f16>,
(mat4x4<f64>) -> mat4x4<f64>,
]
DEBUG arg 0 of type mat2x2<f32>
DEBUG considering rule (mat2x2<{AbstractFloat}>) -> mat2x2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat2x2<f32>) -> mat2x2<f32>
DEBUG types are equivalent
DEBUG considering rule (mat2x2<f16>) -> mat2x2<f16>
DEBUG no conversion possible
DEBUG considering rule (mat2x2<f64>) -> mat2x2<f64>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<{AbstractFloat}>) -> mat3x2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<f32>) -> mat3x2<f32>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<f16>) -> mat3x2<f16>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<f64>) -> mat3x2<f64>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<{AbstractFloat}>) -> mat4x2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<f32>) -> mat4x2<f32>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<f16>) -> mat4x2<f16>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<f64>) -> mat4x2<f64>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<{AbstractFloat}>) -> mat2x3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<f32>) -> mat2x3<f32>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<f16>) -> mat2x3<f16>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<f64>) -> mat2x3<f64>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<{AbstractFloat}>) -> mat3x3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<f32>) -> mat3x3<f32>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<f16>) -> mat3x3<f16>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<f64>) -> mat3x3<f64>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<{AbstractFloat}>) -> mat4x3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<f32>) -> mat4x3<f32>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<f16>) -> mat4x3<f16>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<f64>) -> mat4x3<f64>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<{AbstractFloat}>) -> mat2x4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<f32>) -> mat2x4<f32>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<f16>) -> mat2x4<f16>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<f64>) -> mat2x4<f64>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<{AbstractFloat}>) -> mat3x4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<f32>) -> mat3x4<f32>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<f16>) -> mat3x4<f16>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<f64>) -> mat3x4<f64>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<{AbstractFloat}>) -> mat4x4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<f32>) -> mat4x4<f32>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<f16>) -> mat4x4<f16>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<f64>) -> mat4x4<f64>
DEBUG no conversion possible
DEBUG overloads after arg 0: [
(mat2x2<f32>) -> mat2x2<f32>,
]
DEBUG initial overloads for Transpose, [
(mat2x2<{AbstractFloat}>) -> mat2x2<{AbstractFloat}>,
(mat2x2<f32>) -> mat2x2<f32>,
(mat2x2<f16>) -> mat2x2<f16>,
(mat2x2<f64>) -> mat2x2<f64>,
(mat2x3<{AbstractFloat}>) -> mat3x2<{AbstractFloat}>,
(mat2x3<f32>) -> mat3x2<f32>,
(mat2x3<f16>) -> mat3x2<f16>,
(mat2x3<f64>) -> mat3x2<f64>,
(mat2x4<{AbstractFloat}>) -> mat4x2<{AbstractFloat}>,
(mat2x4<f32>) -> mat4x2<f32>,
(mat2x4<f16>) -> mat4x2<f16>,
(mat2x4<f64>) -> mat4x2<f64>,
(mat3x2<{AbstractFloat}>) -> mat2x3<{AbstractFloat}>,
(mat3x2<f32>) -> mat2x3<f32>,
(mat3x2<f16>) -> mat2x3<f16>,
(mat3x2<f64>) -> mat2x3<f64>,
(mat3x3<{AbstractFloat}>) -> mat3x3<{AbstractFloat}>,
(mat3x3<f32>) -> mat3x3<f32>,
(mat3x3<f16>) -> mat3x3<f16>,
(mat3x3<f64>) -> mat3x3<f64>,
(mat3x4<{AbstractFloat}>) -> mat4x3<{AbstractFloat}>,
(mat3x4<f32>) -> mat4x3<f32>,
(mat3x4<f16>) -> mat4x3<f16>,
(mat3x4<f64>) -> mat4x3<f64>,
(mat4x2<{AbstractFloat}>) -> mat2x4<{AbstractFloat}>,
(mat4x2<f32>) -> mat2x4<f32>,
(mat4x2<f16>) -> mat2x4<f16>,
(mat4x2<f64>) -> mat2x4<f64>,
(mat4x3<{AbstractFloat}>) -> mat3x4<{AbstractFloat}>,
(mat4x3<f32>) -> mat3x4<f32>,
(mat4x3<f16>) -> mat3x4<f16>,
(mat4x3<f64>) -> mat3x4<f64>,
(mat4x4<{AbstractFloat}>) -> mat4x4<{AbstractFloat}>,
(mat4x4<f32>) -> mat4x4<f32>,
(mat4x4<f16>) -> mat4x4<f16>,
(mat4x4<f64>) -> mat4x4<f64>,
]
DEBUG arg 0 of type mat2x2<f32>
DEBUG considering rule (mat2x2<{AbstractFloat}>) -> mat2x2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat2x2<f32>) -> mat2x2<f32>
DEBUG types are equivalent
DEBUG considering rule (mat2x2<f16>) -> mat2x2<f16>
DEBUG no conversion possible
DEBUG considering rule (mat2x2<f64>) -> mat2x2<f64>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<{AbstractFloat}>) -> mat3x2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<f32>) -> mat3x2<f32>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<f16>) -> mat3x2<f16>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<f64>) -> mat3x2<f64>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<{AbstractFloat}>) -> mat4x2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<f32>) -> mat4x2<f32>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<f16>) -> mat4x2<f16>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<f64>) -> mat4x2<f64>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<{AbstractFloat}>) -> mat2x3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<f32>) -> mat2x3<f32>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<f16>) -> mat2x3<f16>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<f64>) -> mat2x3<f64>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<{AbstractFloat}>) -> mat3x3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<f32>) -> mat3x3<f32>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<f16>) -> mat3x3<f16>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<f64>) -> mat3x3<f64>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<{AbstractFloat}>) -> mat4x3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<f32>) -> mat4x3<f32>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<f16>) -> mat4x3<f16>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<f64>) -> mat4x3<f64>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<{AbstractFloat}>) -> mat2x4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<f32>) -> mat2x4<f32>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<f16>) -> mat2x4<f16>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<f64>) -> mat2x4<f64>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<{AbstractFloat}>) -> mat3x4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<f32>) -> mat3x4<f32>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<f16>) -> mat3x4<f16>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<f64>) -> mat3x4<f64>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<{AbstractFloat}>) -> mat4x4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<f32>) -> mat4x4<f32>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<f16>) -> mat4x4<f16>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<f64>) -> mat4x4<f64>
DEBUG no conversion possible
DEBUG overloads after arg 0 of type mat2x2<f32>: [
(mat2x2<f32>) -> mat2x2<f32>,
]
DEBUG initial overloads for Transpose: [
(mat2x2<{AbstractFloat}>) -> mat2x2<{AbstractFloat}>,
(mat2x2<f32>) -> mat2x2<f32>,
(mat2x2<f16>) -> mat2x2<f16>,
(mat2x2<f64>) -> mat2x2<f64>,
(mat2x3<{AbstractFloat}>) -> mat3x2<{AbstractFloat}>,
(mat2x3<f32>) -> mat3x2<f32>,
(mat2x3<f16>) -> mat3x2<f16>,
(mat2x3<f64>) -> mat3x2<f64>,
(mat2x4<{AbstractFloat}>) -> mat4x2<{AbstractFloat}>,
(mat2x4<f32>) -> mat4x2<f32>,
(mat2x4<f16>) -> mat4x2<f16>,
(mat2x4<f64>) -> mat4x2<f64>,
(mat3x2<{AbstractFloat}>) -> mat2x3<{AbstractFloat}>,
(mat3x2<f32>) -> mat2x3<f32>,
(mat3x2<f16>) -> mat2x3<f16>,
(mat3x2<f64>) -> mat2x3<f64>,
(mat3x3<{AbstractFloat}>) -> mat3x3<{AbstractFloat}>,
(mat3x3<f32>) -> mat3x3<f32>,
(mat3x3<f16>) -> mat3x3<f16>,
(mat3x3<f64>) -> mat3x3<f64>,
(mat3x4<{AbstractFloat}>) -> mat4x3<{AbstractFloat}>,
(mat3x4<f32>) -> mat4x3<f32>,
(mat3x4<f16>) -> mat4x3<f16>,
(mat3x4<f64>) -> mat4x3<f64>,
(mat4x2<{AbstractFloat}>) -> mat2x4<{AbstractFloat}>,
(mat4x2<f32>) -> mat2x4<f32>,
(mat4x2<f16>) -> mat2x4<f16>,
(mat4x2<f64>) -> mat2x4<f64>,
(mat4x3<{AbstractFloat}>) -> mat3x4<{AbstractFloat}>,
(mat4x3<f32>) -> mat3x4<f32>,
(mat4x3<f16>) -> mat3x4<f16>,
(mat4x3<f64>) -> mat3x4<f64>,
(mat4x4<{AbstractFloat}>) -> mat4x4<{AbstractFloat}>,
(mat4x4<f32>) -> mat4x4<f32>,
(mat4x4<f16>) -> mat4x4<f16>,
(mat4x4<f64>) -> mat4x4<f64>,
]
DEBUG arg 0 of type mat2x2<f32>
DEBUG considering rule (mat2x2<{AbstractFloat}>) -> mat2x2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat2x2<f32>) -> mat2x2<f32>
DEBUG types are equivalent
DEBUG considering rule (mat2x2<f16>) -> mat2x2<f16>
DEBUG no conversion possible
DEBUG considering rule (mat2x2<f64>) -> mat2x2<f64>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<{AbstractFloat}>) -> mat3x2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<f32>) -> mat3x2<f32>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<f16>) -> mat3x2<f16>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<f64>) -> mat3x2<f64>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<{AbstractFloat}>) -> mat4x2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<f32>) -> mat4x2<f32>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<f16>) -> mat4x2<f16>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<f64>) -> mat4x2<f64>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<{AbstractFloat}>) -> mat2x3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<f32>) -> mat2x3<f32>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<f16>) -> mat2x3<f16>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<f64>) -> mat2x3<f64>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<{AbstractFloat}>) -> mat3x3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<f32>) -> mat3x3<f32>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<f16>) -> mat3x3<f16>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<f64>) -> mat3x3<f64>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<{AbstractFloat}>) -> mat4x3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<f32>) -> mat4x3<f32>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<f16>) -> mat4x3<f16>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<f64>) -> mat4x3<f64>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<{AbstractFloat}>) -> mat2x4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<f32>) -> mat2x4<f32>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<f16>) -> mat2x4<f16>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<f64>) -> mat2x4<f64>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<{AbstractFloat}>) -> mat3x4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<f32>) -> mat3x4<f32>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<f16>) -> mat3x4<f16>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<f64>) -> mat3x4<f64>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<{AbstractFloat}>) -> mat4x4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<f32>) -> mat4x4<f32>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<f16>) -> mat4x4<f16>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<f64>) -> mat4x4<f64>
DEBUG no conversion possible
DEBUG overloads after arg 0: [
(mat2x2<f32>) -> mat2x2<f32>,
]
DEBUG initial overloads for Pow, List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type vec3<f32>: List {
rules: [
(vec3<f32>, vec3<f32>) -> vec3<f32>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type vec3<f32>: List {
rules: [
(vec3<f32>, vec3<f32>) -> vec3<f32>,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Pow: List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(vec3<f32>, vec3<f32>) -> vec3<f32>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1: List {
rules: [
(vec3<f32>, vec3<f32>) -> vec3<f32>,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Pow, List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Pow: List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Pow, List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type vec3<f32>: List {
rules: [
(vec3<f32>, vec3<f32>) -> vec3<f32>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type vec3<f32>: List {
rules: [
(vec3<f32>, vec3<f32>) -> vec3<f32>,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Pow: List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(vec3<f32>, vec3<f32>) -> vec3<f32>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1: List {
rules: [
(vec3<f32>, vec3<f32>) -> vec3<f32>,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Abs, List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Abs, List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG var LocalVariable { name: Some("color"), ty: [1], init: None }
DEBUG initial overloads for Abs: List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Abs: List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Pow, List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Pow, List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Pow, List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Pow: List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Pow: List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Pow: List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Exp, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Exp: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Sign, List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type vec2<f32>: List {
rules: [
(vec2<f32>) -> vec2<f32>,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Abs, List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type vec2<f32>: List {
rules: [
(vec2<f32>) -> vec2<f32>,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Sign: List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(vec2<f32>) -> vec2<f32>,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Abs: List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(vec2<f32>) -> vec2<f32>,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Abs, List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Min, List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Max, List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Sqrt, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Abs: List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Min: List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Max: List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Sqrt: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Max, List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Max, List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type vec2<f32>: List {
rules: [
(vec2<f32>, vec2<f32>) -> vec2<f32>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type vec2<f32>: List {
rules: [
(vec2<f32>, vec2<f32>) -> vec2<f32>,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Length, List {
rules: [
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<f32>) -> f32,
(vec2<f16>) -> f16,
(vec2<f64>) -> f64,
(vec3<f32>) -> f32,
(vec3<f16>) -> f16,
(vec3<f64>) -> f64,
(vec4<f32>) -> f32,
(vec4<f16>) -> f16,
(vec4<f64>) -> f64,
],
conclude: Scalar,
}
DEBUG overloads after arg 0 of type vec2<f32>: List {
rules: [
(vec2<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG initial overloads for Max, List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Min, List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Max: List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Max: List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(vec2<f32>, vec2<f32>) -> vec2<f32>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1: List {
rules: [
(vec2<f32>, vec2<f32>) -> vec2<f32>,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Length: List {
rules: [
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<f32>) -> f32,
(vec2<f16>) -> f16,
(vec2<f64>) -> f64,
(vec3<f32>) -> f32,
(vec3<f16>) -> f16,
(vec3<f64>) -> f64,
(vec4<f32>) -> f32,
(vec4<f16>) -> f16,
(vec4<f64>) -> f64,
],
conclude: Scalar,
}
DEBUG overloads after arg 0: List {
rules: [
(vec2<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG initial overloads for Max: List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Min: List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Abs, List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type vec2<f32>: List {
rules: [
(vec2<f32>) -> vec2<f32>,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Abs: List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(vec2<f32>) -> vec2<f32>,
],
conclude: ArgumentType,
}
DEBUG var LocalVariable { name: Some("result"), ty: [22], init: Some([4]) }
DEBUG initial overloads for Cos, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Sin, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Dot, List {
rules: [
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> {AbstractInt},
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> {AbstractFloat},
(vec2<i32>, vec2<i32>) -> i32,
(vec2<i64>, vec2<i64>) -> i64,
(vec2<u32>, vec2<u32>) -> u32,
(vec2<u64>, vec2<u64>) -> u64,
(vec2<f32>, vec2<f32>) -> f32,
(vec2<f16>, vec2<f16>) -> f16,
(vec2<f64>, vec2<f64>) -> f64,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> {AbstractInt},
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> {AbstractFloat},
(vec3<i32>, vec3<i32>) -> i32,
(vec3<i64>, vec3<i64>) -> i64,
(vec3<u32>, vec3<u32>) -> u32,
(vec3<u64>, vec3<u64>) -> u64,
(vec3<f32>, vec3<f32>) -> f32,
(vec3<f16>, vec3<f16>) -> f16,
(vec3<f64>, vec3<f64>) -> f64,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> {AbstractInt},
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> {AbstractFloat},
(vec4<i32>, vec4<i32>) -> i32,
(vec4<i64>, vec4<i64>) -> i64,
(vec4<u32>, vec4<u32>) -> u32,
(vec4<u64>, vec4<u64>) -> u64,
(vec4<f32>, vec4<f32>) -> f32,
(vec4<f16>, vec4<f16>) -> f16,
(vec4<f64>, vec4<f64>) -> f64,
],
conclude: Scalar,
}
DEBUG overloads after arg 0 of type vec2<f32>: List {
rules: [
(vec2<f32>, vec2<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG overloads after arg 1 of type vec2<f32>: List {
rules: [
(vec2<f32>, vec2<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG initial overloads for Length, List {
rules: [
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<f32>) -> f32,
(vec2<f16>) -> f16,
(vec2<f64>) -> f64,
(vec3<f32>) -> f32,
(vec3<f16>) -> f16,
(vec3<f64>) -> f64,
(vec4<f32>) -> f32,
(vec4<f16>) -> f16,
(vec4<f64>) -> f64,
],
conclude: Scalar,
}
DEBUG overloads after arg 0 of type vec2<f32>: List {
rules: [
(vec2<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG initial overloads for Abs, List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Abs, List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Clamp, List {
rules: [
({AbstractInt}, {AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32, i32) -> i32,
(i64, i64, i64) -> i64,
(u32, u32, u32) -> u32,
(u64, u64, u64) -> u64,
(f32, f32, f32) -> f32,
(f16, f16, f16) -> f16,
(f64, f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Mix, [
({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, {AbstractFloat}) -> vec2<{AbstractFloat}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, {AbstractFloat}) -> vec3<{AbstractFloat}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, {AbstractFloat}) -> vec4<{AbstractFloat}>,
(f32, f32, f32) -> f32,
(f32, f32, f32) -> f32,
(vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f32>, vec2<f32>, f32) -> vec2<f32>,
(vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f32>, vec3<f32>, f32) -> vec3<f32>,
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
(f16, f16, f16) -> f16,
(f16, f16, f16) -> f16,
(vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f16>, vec2<f16>, f16) -> vec2<f16>,
(vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f16>, vec3<f16>, f16) -> vec3<f16>,
(vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f16>, vec4<f16>, f16) -> vec4<f16>,
(f64, f64, f64) -> f64,
(f64, f64, f64) -> f64,
(vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec2<f64>, vec2<f64>, f64) -> vec2<f64>,
(vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec3<f64>, vec3<f64>, f64) -> vec3<f64>,
(vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64>,
(vec4<f64>, vec4<f64>, f64) -> vec4<f64>,
]
DEBUG arg 0 of type vec4<f32>
DEBUG considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat}
DEBUG no conversion possible
DEBUG considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat}
DEBUG no conversion possible
DEBUG considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, {AbstractFloat}) -> vec2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, {AbstractFloat}) -> vec3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, {AbstractFloat}) -> vec4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (f32, f32, f32) -> f32
DEBUG no conversion possible
DEBUG considering rule (f32, f32, f32) -> f32
DEBUG no conversion possible
DEBUG considering rule (vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32>
DEBUG no conversion possible
DEBUG considering rule (vec2<f32>, vec2<f32>, f32) -> vec2<f32>
DEBUG no conversion possible
DEBUG considering rule (vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32>
DEBUG no conversion possible
DEBUG considering rule (vec3<f32>, vec3<f32>, f32) -> vec3<f32>
DEBUG no conversion possible
DEBUG considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>
DEBUG types are equivalent
DEBUG considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32>
DEBUG types are equivalent
DEBUG considering rule (f16, f16, f16) -> f16
DEBUG no conversion possible
DEBUG considering rule (f16, f16, f16) -> f16
DEBUG no conversion possible
DEBUG considering rule (vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16>
DEBUG no conversion possible
DEBUG considering rule (vec2<f16>, vec2<f16>, f16) -> vec2<f16>
DEBUG no conversion possible
DEBUG considering rule (vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16>
DEBUG no conversion possible
DEBUG considering rule (vec3<f16>, vec3<f16>, f16) -> vec3<f16>
DEBUG no conversion possible
DEBUG considering rule (vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16>
DEBUG no conversion possible
DEBUG considering rule (vec4<f16>, vec4<f16>, f16) -> vec4<f16>
DEBUG no conversion possible
DEBUG considering rule (f64, f64, f64) -> f64
DEBUG no conversion possible
DEBUG considering rule (f64, f64, f64) -> f64
DEBUG no conversion possible
DEBUG considering rule (vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64>
DEBUG no conversion possible
DEBUG considering rule (vec2<f64>, vec2<f64>, f64) -> vec2<f64>
DEBUG no conversion possible
DEBUG considering rule (vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64>
DEBUG no conversion possible
DEBUG considering rule (vec3<f64>, vec3<f64>, f64) -> vec3<f64>
DEBUG no conversion possible
DEBUG considering rule (vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64>
DEBUG no conversion possible
DEBUG considering rule (vec4<f64>, vec4<f64>, f64) -> vec4<f64>
DEBUG no conversion possible
DEBUG overloads after arg 0 of type vec4<f32>: [
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
]
DEBUG arg 1 of type vec4<f32>
DEBUG considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>
DEBUG types are equivalent
DEBUG considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32>
DEBUG types are equivalent
DEBUG overloads after arg 1 of type vec4<f32>: [
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
]
DEBUG initial overloads for Mix, [
({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, {AbstractFloat}) -> vec2<{AbstractFloat}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, {AbstractFloat}) -> vec3<{AbstractFloat}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, {AbstractFloat}) -> vec4<{AbstractFloat}>,
(f32, f32, f32) -> f32,
(f32, f32, f32) -> f32,
(vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f32>, vec2<f32>, f32) -> vec2<f32>,
(vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f32>, vec3<f32>, f32) -> vec3<f32>,
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
(f16, f16, f16) -> f16,
(f16, f16, f16) -> f16,
(vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f16>, vec2<f16>, f16) -> vec2<f16>,
(vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f16>, vec3<f16>, f16) -> vec3<f16>,
(vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f16>, vec4<f16>, f16) -> vec4<f16>,
(f64, f64, f64) -> f64,
(f64, f64, f64) -> f64,
(vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec2<f64>, vec2<f64>, f64) -> vec2<f64>,
(vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec3<f64>, vec3<f64>, f64) -> vec3<f64>,
(vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64>,
(vec4<f64>, vec4<f64>, f64) -> vec4<f64>,
]
DEBUG arg 0 of type vec4<f32>
DEBUG considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat}
DEBUG no conversion possible
DEBUG considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat}
DEBUG no conversion possible
DEBUG considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, {AbstractFloat}) -> vec2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, {AbstractFloat}) -> vec3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, {AbstractFloat}) -> vec4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (f32, f32, f32) -> f32
DEBUG no conversion possible
DEBUG considering rule (f32, f32, f32) -> f32
DEBUG no conversion possible
DEBUG considering rule (vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32>
DEBUG no conversion possible
DEBUG considering rule (vec2<f32>, vec2<f32>, f32) -> vec2<f32>
DEBUG no conversion possible
DEBUG considering rule (vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32>
DEBUG no conversion possible
DEBUG considering rule (vec3<f32>, vec3<f32>, f32) -> vec3<f32>
DEBUG no conversion possible
DEBUG considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>
DEBUG types are equivalent
DEBUG considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32>
DEBUG types are equivalent
DEBUG considering rule (f16, f16, f16) -> f16
DEBUG no conversion possible
DEBUG considering rule (f16, f16, f16) -> f16
DEBUG no conversion possible
DEBUG considering rule (vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16>
DEBUG no conversion possible
DEBUG considering rule (vec2<f16>, vec2<f16>, f16) -> vec2<f16>
DEBUG no conversion possible
DEBUG considering rule (vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16>
DEBUG no conversion possible
DEBUG considering rule (vec3<f16>, vec3<f16>, f16) -> vec3<f16>
DEBUG no conversion possible
DEBUG considering rule (vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16>
DEBUG no conversion possible
DEBUG considering rule (vec4<f16>, vec4<f16>, f16) -> vec4<f16>
DEBUG no conversion possible
DEBUG considering rule (f64, f64, f64) -> f64
DEBUG no conversion possible
DEBUG considering rule (f64, f64, f64) -> f64
DEBUG no conversion possible
DEBUG considering rule (vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64>
DEBUG no conversion possible
DEBUG considering rule (vec2<f64>, vec2<f64>, f64) -> vec2<f64>
DEBUG no conversion possible
DEBUG considering rule (vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64>
DEBUG no conversion possible
DEBUG considering rule (vec3<f64>, vec3<f64>, f64) -> vec3<f64>
DEBUG no conversion possible
DEBUG considering rule (vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64>
DEBUG no conversion possible
DEBUG considering rule (vec4<f64>, vec4<f64>, f64) -> vec4<f64>
DEBUG no conversion possible
DEBUG overloads after arg 0 of type vec4<f32>: [
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
]
DEBUG arg 1 of type vec4<f32>
DEBUG considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>
DEBUG types are equivalent
DEBUG considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32>
DEBUG types are equivalent
DEBUG overloads after arg 1 of type vec4<f32>: [
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
]
DEBUG initial overloads for Sin, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Cos, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Sin, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Sin, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Cos, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Min, List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Saturate, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG var LocalVariable { name: Some("background_color"), ty: [2], init: Some([7]) }
DEBUG var LocalVariable { name: Some("direction"), ty: [3], init: None }
DEBUG var LocalVariable { name: Some("t"), ty: [0], init: None }
DEBUG initial overloads for Cos: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Sin: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Dot: List {
rules: [
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> {AbstractInt},
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> {AbstractFloat},
(vec2<i32>, vec2<i32>) -> i32,
(vec2<i64>, vec2<i64>) -> i64,
(vec2<u32>, vec2<u32>) -> u32,
(vec2<u64>, vec2<u64>) -> u64,
(vec2<f32>, vec2<f32>) -> f32,
(vec2<f16>, vec2<f16>) -> f16,
(vec2<f64>, vec2<f64>) -> f64,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> {AbstractInt},
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> {AbstractFloat},
(vec3<i32>, vec3<i32>) -> i32,
(vec3<i64>, vec3<i64>) -> i64,
(vec3<u32>, vec3<u32>) -> u32,
(vec3<u64>, vec3<u64>) -> u64,
(vec3<f32>, vec3<f32>) -> f32,
(vec3<f16>, vec3<f16>) -> f16,
(vec3<f64>, vec3<f64>) -> f64,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> {AbstractInt},
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> {AbstractFloat},
(vec4<i32>, vec4<i32>) -> i32,
(vec4<i64>, vec4<i64>) -> i64,
(vec4<u32>, vec4<u32>) -> u32,
(vec4<u64>, vec4<u64>) -> u64,
(vec4<f32>, vec4<f32>) -> f32,
(vec4<f16>, vec4<f16>) -> f16,
(vec4<f64>, vec4<f64>) -> f64,
],
conclude: Scalar,
}
DEBUG overloads after arg 0: List {
rules: [
(vec2<f32>, vec2<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG overloads after arg 1: List {
rules: [
(vec2<f32>, vec2<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG initial overloads for Length: List {
rules: [
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<f32>) -> f32,
(vec2<f16>) -> f16,
(vec2<f64>) -> f64,
(vec3<f32>) -> f32,
(vec3<f16>) -> f16,
(vec3<f64>) -> f64,
(vec4<f32>) -> f32,
(vec4<f16>) -> f16,
(vec4<f64>) -> f64,
],
conclude: Scalar,
}
DEBUG overloads after arg 0: List {
rules: [
(vec2<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG initial overloads for Abs: List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Abs: List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Clamp: List {
rules: [
({AbstractInt}, {AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32, i32) -> i32,
(i64, i64, i64) -> i64,
(u32, u32, u32) -> u32,
(u64, u64, u64) -> u64,
(f32, f32, f32) -> f32,
(f16, f16, f16) -> f16,
(f64, f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32, f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1: List {
rules: [
(f32, f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 2: List {
rules: [
(f32, f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Mix: [
({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, {AbstractFloat}) -> vec2<{AbstractFloat}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, {AbstractFloat}) -> vec3<{AbstractFloat}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, {AbstractFloat}) -> vec4<{AbstractFloat}>,
(f32, f32, f32) -> f32,
(f32, f32, f32) -> f32,
(vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f32>, vec2<f32>, f32) -> vec2<f32>,
(vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f32>, vec3<f32>, f32) -> vec3<f32>,
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
(f16, f16, f16) -> f16,
(f16, f16, f16) -> f16,
(vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f16>, vec2<f16>, f16) -> vec2<f16>,
(vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f16>, vec3<f16>, f16) -> vec3<f16>,
(vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f16>, vec4<f16>, f16) -> vec4<f16>,
(f64, f64, f64) -> f64,
(f64, f64, f64) -> f64,
(vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec2<f64>, vec2<f64>, f64) -> vec2<f64>,
(vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec3<f64>, vec3<f64>, f64) -> vec3<f64>,
(vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64>,
(vec4<f64>, vec4<f64>, f64) -> vec4<f64>,
]
DEBUG arg 0 of type vec4<f32>
DEBUG considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat}
DEBUG no conversion possible
DEBUG considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat}
DEBUG no conversion possible
DEBUG considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, {AbstractFloat}) -> vec2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, {AbstractFloat}) -> vec3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, {AbstractFloat}) -> vec4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (f32, f32, f32) -> f32
DEBUG no conversion possible
DEBUG considering rule (f32, f32, f32) -> f32
DEBUG no conversion possible
DEBUG considering rule (vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32>
DEBUG no conversion possible
DEBUG considering rule (vec2<f32>, vec2<f32>, f32) -> vec2<f32>
DEBUG no conversion possible
DEBUG considering rule (vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32>
DEBUG no conversion possible
DEBUG considering rule (vec3<f32>, vec3<f32>, f32) -> vec3<f32>
DEBUG no conversion possible
DEBUG considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>
DEBUG types are equivalent
DEBUG considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32>
DEBUG types are equivalent
DEBUG considering rule (f16, f16, f16) -> f16
DEBUG no conversion possible
DEBUG considering rule (f16, f16, f16) -> f16
DEBUG no conversion possible
DEBUG considering rule (vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16>
DEBUG no conversion possible
DEBUG considering rule (vec2<f16>, vec2<f16>, f16) -> vec2<f16>
DEBUG no conversion possible
DEBUG considering rule (vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16>
DEBUG no conversion possible
DEBUG considering rule (vec3<f16>, vec3<f16>, f16) -> vec3<f16>
DEBUG no conversion possible
DEBUG considering rule (vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16>
DEBUG no conversion possible
DEBUG considering rule (vec4<f16>, vec4<f16>, f16) -> vec4<f16>
DEBUG no conversion possible
DEBUG considering rule (f64, f64, f64) -> f64
DEBUG no conversion possible
DEBUG considering rule (f64, f64, f64) -> f64
DEBUG no conversion possible
DEBUG considering rule (vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64>
DEBUG no conversion possible
DEBUG considering rule (vec2<f64>, vec2<f64>, f64) -> vec2<f64>
DEBUG no conversion possible
DEBUG considering rule (vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64>
DEBUG no conversion possible
DEBUG considering rule (vec3<f64>, vec3<f64>, f64) -> vec3<f64>
DEBUG no conversion possible
DEBUG considering rule (vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64>
DEBUG no conversion possible
DEBUG considering rule (vec4<f64>, vec4<f64>, f64) -> vec4<f64>
DEBUG no conversion possible
DEBUG overloads after arg 0: [
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
]
DEBUG arg 1 of type vec4<f32>
DEBUG considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>
DEBUG types are equivalent
DEBUG considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32>
DEBUG types are equivalent
DEBUG overloads after arg 1: [
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
]
DEBUG arg 2 of type f32
DEBUG considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>
DEBUG no conversion possible
DEBUG considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32>
DEBUG types are equivalent
DEBUG overloads after arg 2: [
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
]
DEBUG initial overloads for Mix: [
({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, {AbstractFloat}) -> vec2<{AbstractFloat}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, {AbstractFloat}) -> vec3<{AbstractFloat}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, {AbstractFloat}) -> vec4<{AbstractFloat}>,
(f32, f32, f32) -> f32,
(f32, f32, f32) -> f32,
(vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f32>, vec2<f32>, f32) -> vec2<f32>,
(vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f32>, vec3<f32>, f32) -> vec3<f32>,
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
(f16, f16, f16) -> f16,
(f16, f16, f16) -> f16,
(vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f16>, vec2<f16>, f16) -> vec2<f16>,
(vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f16>, vec3<f16>, f16) -> vec3<f16>,
(vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f16>, vec4<f16>, f16) -> vec4<f16>,
(f64, f64, f64) -> f64,
(f64, f64, f64) -> f64,
(vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec2<f64>, vec2<f64>, f64) -> vec2<f64>,
(vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec3<f64>, vec3<f64>, f64) -> vec3<f64>,
(vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64>,
(vec4<f64>, vec4<f64>, f64) -> vec4<f64>,
]
DEBUG arg 0 of type vec4<f32>
DEBUG considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat}
DEBUG no conversion possible
DEBUG considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat}
DEBUG no conversion possible
DEBUG considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, {AbstractFloat}) -> vec2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, {AbstractFloat}) -> vec3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, {AbstractFloat}) -> vec4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (f32, f32, f32) -> f32
DEBUG no conversion possible
DEBUG considering rule (f32, f32, f32) -> f32
DEBUG no conversion possible
DEBUG considering rule (vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32>
DEBUG no conversion possible
DEBUG considering rule (vec2<f32>, vec2<f32>, f32) -> vec2<f32>
DEBUG no conversion possible
DEBUG considering rule (vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32>
DEBUG no conversion possible
DEBUG considering rule (vec3<f32>, vec3<f32>, f32) -> vec3<f32>
DEBUG no conversion possible
DEBUG considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>
DEBUG types are equivalent
DEBUG considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32>
DEBUG types are equivalent
DEBUG considering rule (f16, f16, f16) -> f16
DEBUG no conversion possible
DEBUG considering rule (f16, f16, f16) -> f16
DEBUG no conversion possible
DEBUG considering rule (vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16>
DEBUG no conversion possible
DEBUG considering rule (vec2<f16>, vec2<f16>, f16) -> vec2<f16>
DEBUG no conversion possible
DEBUG considering rule (vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16>
DEBUG no conversion possible
DEBUG considering rule (vec3<f16>, vec3<f16>, f16) -> vec3<f16>
DEBUG no conversion possible
DEBUG considering rule (vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16>
DEBUG no conversion possible
DEBUG considering rule (vec4<f16>, vec4<f16>, f16) -> vec4<f16>
DEBUG no conversion possible
DEBUG considering rule (f64, f64, f64) -> f64
DEBUG no conversion possible
DEBUG considering rule (f64, f64, f64) -> f64
DEBUG no conversion possible
DEBUG considering rule (vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64>
DEBUG no conversion possible
DEBUG considering rule (vec2<f64>, vec2<f64>, f64) -> vec2<f64>
DEBUG no conversion possible
DEBUG considering rule (vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64>
DEBUG no conversion possible
DEBUG considering rule (vec3<f64>, vec3<f64>, f64) -> vec3<f64>
DEBUG no conversion possible
DEBUG considering rule (vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64>
DEBUG no conversion possible
DEBUG considering rule (vec4<f64>, vec4<f64>, f64) -> vec4<f64>
DEBUG no conversion possible
DEBUG overloads after arg 0: [
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
]
DEBUG arg 1 of type vec4<f32>
DEBUG considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>
DEBUG types are equivalent
DEBUG considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32>
DEBUG types are equivalent
DEBUG overloads after arg 1: [
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
]
DEBUG arg 2 of type f32
DEBUG considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>
DEBUG no conversion possible
DEBUG considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32>
DEBUG types are equivalent
DEBUG overloads after arg 2: [
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
]
DEBUG initial overloads for Sin: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Cos: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Sin: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Sin: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Cos: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Min: List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Saturate: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Length, List {
rules: [
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<f32>) -> f32,
(vec2<f16>) -> f16,
(vec2<f64>) -> f64,
(vec3<f32>) -> f32,
(vec3<f16>) -> f16,
(vec3<f64>) -> f64,
(vec4<f32>) -> f32,
(vec4<f16>) -> f16,
(vec4<f64>) -> f64,
],
conclude: Scalar,
}
DEBUG overloads after arg 0 of type vec2<f32>: List {
rules: [
(vec2<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG initial overloads for Length: List {
rules: [
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<f32>) -> f32,
(vec2<f16>) -> f16,
(vec2<f64>) -> f64,
(vec3<f32>) -> f32,
(vec3<f16>) -> f16,
(vec3<f64>) -> f64,
(vec4<f32>) -> f32,
(vec4<f16>) -> f16,
(vec4<f64>) -> f64,
],
conclude: Scalar,
}
DEBUG overloads after arg 0: List {
rules: [
(vec2<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG initial overloads for Min, List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Min: List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Trunc, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Trunc: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Abs, List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Saturate, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Abs: List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Saturate: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG var LocalVariable { name: Some("out"), ty: [25], init: Some([14]) }
DEBUG initial overloads for Abs, List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type vec2<f32>: List {
rules: [
(vec2<f32>) -> vec2<f32>,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Max, List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Max, List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type vec2<f32>: List {
rules: [
(vec2<f32>, vec2<f32>) -> vec2<f32>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type vec2<f32>: List {
rules: [
(vec2<f32>, vec2<f32>) -> vec2<f32>,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Max, List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Max, List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Max, List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Atan2, List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Floor, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Saturate, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Mix, [
({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, {AbstractFloat}) -> vec2<{AbstractFloat}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, {AbstractFloat}) -> vec3<{AbstractFloat}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, {AbstractFloat}) -> vec4<{AbstractFloat}>,
(f32, f32, f32) -> f32,
(f32, f32, f32) -> f32,
(vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f32>, vec2<f32>, f32) -> vec2<f32>,
(vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f32>, vec3<f32>, f32) -> vec3<f32>,
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
(f16, f16, f16) -> f16,
(f16, f16, f16) -> f16,
(vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f16>, vec2<f16>, f16) -> vec2<f16>,
(vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f16>, vec3<f16>, f16) -> vec3<f16>,
(vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f16>, vec4<f16>, f16) -> vec4<f16>,
(f64, f64, f64) -> f64,
(f64, f64, f64) -> f64,
(vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec2<f64>, vec2<f64>, f64) -> vec2<f64>,
(vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec3<f64>, vec3<f64>, f64) -> vec3<f64>,
(vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64>,
(vec4<f64>, vec4<f64>, f64) -> vec4<f64>,
]
DEBUG arg 0 of type vec4<f32>
DEBUG considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat}
DEBUG no conversion possible
DEBUG considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat}
DEBUG no conversion possible
DEBUG considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, {AbstractFloat}) -> vec2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, {AbstractFloat}) -> vec3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, {AbstractFloat}) -> vec4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (f32, f32, f32) -> f32
DEBUG no conversion possible
DEBUG considering rule (f32, f32, f32) -> f32
DEBUG no conversion possible
DEBUG considering rule (vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32>
DEBUG no conversion possible
DEBUG considering rule (vec2<f32>, vec2<f32>, f32) -> vec2<f32>
DEBUG no conversion possible
DEBUG considering rule (vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32>
DEBUG no conversion possible
DEBUG considering rule (vec3<f32>, vec3<f32>, f32) -> vec3<f32>
DEBUG no conversion possible
DEBUG considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>
DEBUG types are equivalent
DEBUG considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32>
DEBUG types are equivalent
DEBUG considering rule (f16, f16, f16) -> f16
DEBUG no conversion possible
DEBUG considering rule (f16, f16, f16) -> f16
DEBUG no conversion possible
DEBUG considering rule (vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16>
DEBUG no conversion possible
DEBUG considering rule (vec2<f16>, vec2<f16>, f16) -> vec2<f16>
DEBUG no conversion possible
DEBUG considering rule (vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16>
DEBUG no conversion possible
DEBUG considering rule (vec3<f16>, vec3<f16>, f16) -> vec3<f16>
DEBUG no conversion possible
DEBUG considering rule (vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16>
DEBUG no conversion possible
DEBUG considering rule (vec4<f16>, vec4<f16>, f16) -> vec4<f16>
DEBUG no conversion possible
DEBUG considering rule (f64, f64, f64) -> f64
DEBUG no conversion possible
DEBUG considering rule (f64, f64, f64) -> f64
DEBUG no conversion possible
DEBUG considering rule (vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64>
DEBUG no conversion possible
DEBUG considering rule (vec2<f64>, vec2<f64>, f64) -> vec2<f64>
DEBUG no conversion possible
DEBUG considering rule (vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64>
DEBUG no conversion possible
DEBUG considering rule (vec3<f64>, vec3<f64>, f64) -> vec3<f64>
DEBUG no conversion possible
DEBUG considering rule (vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64>
DEBUG no conversion possible
DEBUG considering rule (vec4<f64>, vec4<f64>, f64) -> vec4<f64>
DEBUG no conversion possible
DEBUG overloads after arg 0 of type vec4<f32>: [
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
]
DEBUG arg 1 of type vec4<f32>
DEBUG considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>
DEBUG types are equivalent
DEBUG considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32>
DEBUG types are equivalent
DEBUG overloads after arg 1 of type vec4<f32>: [
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
]
DEBUG initial overloads for Saturate, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG var LocalVariable { name: Some("inner_sdf"), ty: [0], init: Some([136]) }
DEBUG var LocalVariable { name: Some("color"), ty: [2], init: None }
DEBUG var LocalVariable { name: Some("border_color"), ty: [2], init: None }
DEBUG var LocalVariable { name: Some("t"), ty: [0], init: Some([171]) }
DEBUG var LocalVariable { name: Some("max_t"), ty: [0], init: Some([173]) }
DEBUG var LocalVariable { name: Some("dash_velocity"), ty: [0], init: Some([178]) }
DEBUG initial overloads for Abs: List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(vec2<f32>) -> vec2<f32>,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Max: List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Max: List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(vec2<f32>, vec2<f32>) -> vec2<f32>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1: List {
rules: [
(vec2<f32>, vec2<f32>) -> vec2<f32>,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Max: List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Max: List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Max: List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Atan2: List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Floor: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Saturate: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Mix: [
({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, {AbstractFloat}) -> vec2<{AbstractFloat}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, {AbstractFloat}) -> vec3<{AbstractFloat}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, {AbstractFloat}) -> vec4<{AbstractFloat}>,
(f32, f32, f32) -> f32,
(f32, f32, f32) -> f32,
(vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f32>, vec2<f32>, f32) -> vec2<f32>,
(vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f32>, vec3<f32>, f32) -> vec3<f32>,
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
(f16, f16, f16) -> f16,
(f16, f16, f16) -> f16,
(vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f16>, vec2<f16>, f16) -> vec2<f16>,
(vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f16>, vec3<f16>, f16) -> vec3<f16>,
(vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f16>, vec4<f16>, f16) -> vec4<f16>,
(f64, f64, f64) -> f64,
(f64, f64, f64) -> f64,
(vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec2<f64>, vec2<f64>, f64) -> vec2<f64>,
(vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec3<f64>, vec3<f64>, f64) -> vec3<f64>,
(vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64>,
(vec4<f64>, vec4<f64>, f64) -> vec4<f64>,
]
DEBUG arg 0 of type vec4<f32>
DEBUG considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat}
DEBUG no conversion possible
DEBUG considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat}
DEBUG no conversion possible
DEBUG considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, {AbstractFloat}) -> vec2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, {AbstractFloat}) -> vec3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, {AbstractFloat}) -> vec4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (f32, f32, f32) -> f32
DEBUG no conversion possible
DEBUG considering rule (f32, f32, f32) -> f32
DEBUG no conversion possible
DEBUG considering rule (vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32>
DEBUG no conversion possible
DEBUG considering rule (vec2<f32>, vec2<f32>, f32) -> vec2<f32>
DEBUG no conversion possible
DEBUG considering rule (vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32>
DEBUG no conversion possible
DEBUG considering rule (vec3<f32>, vec3<f32>, f32) -> vec3<f32>
DEBUG no conversion possible
DEBUG considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>
DEBUG types are equivalent
DEBUG considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32>
DEBUG types are equivalent
DEBUG considering rule (f16, f16, f16) -> f16
DEBUG no conversion possible
DEBUG considering rule (f16, f16, f16) -> f16
DEBUG no conversion possible
DEBUG considering rule (vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16>
DEBUG no conversion possible
DEBUG considering rule (vec2<f16>, vec2<f16>, f16) -> vec2<f16>
DEBUG no conversion possible
DEBUG considering rule (vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16>
DEBUG no conversion possible
DEBUG considering rule (vec3<f16>, vec3<f16>, f16) -> vec3<f16>
DEBUG no conversion possible
DEBUG considering rule (vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16>
DEBUG no conversion possible
DEBUG considering rule (vec4<f16>, vec4<f16>, f16) -> vec4<f16>
DEBUG no conversion possible
DEBUG considering rule (f64, f64, f64) -> f64
DEBUG no conversion possible
DEBUG considering rule (f64, f64, f64) -> f64
DEBUG no conversion possible
DEBUG considering rule (vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64>
DEBUG no conversion possible
DEBUG considering rule (vec2<f64>, vec2<f64>, f64) -> vec2<f64>
DEBUG no conversion possible
DEBUG considering rule (vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64>
DEBUG no conversion possible
DEBUG considering rule (vec3<f64>, vec3<f64>, f64) -> vec3<f64>
DEBUG no conversion possible
DEBUG considering rule (vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64>
DEBUG no conversion possible
DEBUG considering rule (vec4<f64>, vec4<f64>, f64) -> vec4<f64>
DEBUG no conversion possible
DEBUG overloads after arg 0: [
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
]
DEBUG arg 1 of type vec4<f32>
DEBUG considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>
DEBUG types are equivalent
DEBUG considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32>
DEBUG types are equivalent
DEBUG overloads after arg 1: [
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
]
DEBUG arg 2 of type f32
DEBUG considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>
DEBUG no conversion possible
DEBUG considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32>
DEBUG types are equivalent
DEBUG overloads after arg 2: [
(vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
]
DEBUG initial overloads for Saturate: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG var LocalVariable { name: Some("shadow"), ty: [26], init: None }
DEBUG var LocalVariable { name: Some("out"), ty: [28], init: Some([31]) }
DEBUG initial overloads for Clamp, List {
rules: [
({AbstractInt}, {AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32, i32) -> i32,
(i64, i64, i64) -> i64,
(u32, u32, u32) -> u32,
(u64, u64, u64) -> u64,
(f32, f32, f32) -> f32,
(f16, f16, f16) -> f16,
(f64, f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Clamp, List {
rules: [
({AbstractInt}, {AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32, i32) -> i32,
(i64, i64, i64) -> i64,
(u32, u32, u32) -> u32,
(u64, u64, u64) -> u64,
(f32, f32, f32) -> f32,
(f16, f16, f16) -> f16,
(f64, f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG var LocalVariable { name: Some("y"), ty: [0], init: None }
DEBUG var LocalVariable { name: Some("alpha"), ty: [0], init: Some([46]) }
DEBUG var LocalVariable { name: Some("i"), ty: [16], init: Some([48]) }
DEBUG initial overloads for Clamp: List {
rules: [
({AbstractInt}, {AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32, i32) -> i32,
(i64, i64, i64) -> i64,
(u32, u32, u32) -> u32,
(u64, u64, u64) -> u64,
(f32, f32, f32) -> f32,
(f16, f16, f16) -> f16,
(f64, f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32, f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1: List {
rules: [
(f32, f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 2: List {
rules: [
(f32, f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Clamp: List {
rules: [
({AbstractInt}, {AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32, i32) -> i32,
(i64, i64, i64) -> i64,
(u32, u32, u32) -> u32,
(u64, u64, u64) -> u64,
(f32, f32, f32) -> f32,
(f16, f16, f16) -> f16,
(f64, f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32, f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1: List {
rules: [
(f32, f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 2: List {
rules: [
(f32, f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG var LocalVariable { name: Some("out"), ty: [31], init: Some([4]) }
DEBUG initial overloads for Length, List {
rules: [
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<f32>) -> f32,
(vec2<f16>) -> f16,
(vec2<f64>) -> f64,
(vec3<f32>) -> f32,
(vec3<f16>) -> f16,
(vec3<f64>) -> f64,
(vec4<f32>) -> f32,
(vec4<f16>) -> f16,
(vec4<f64>) -> f64,
],
conclude: Scalar,
}
DEBUG overloads after arg 0 of type vec2<f32>: List {
rules: [
(vec2<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG initial overloads for Length, List {
rules: [
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<f32>) -> f32,
(vec2<f16>) -> f16,
(vec2<f64>) -> f64,
(vec3<f32>) -> f32,
(vec3<f16>) -> f16,
(vec3<f64>) -> f64,
(vec4<f32>) -> f32,
(vec4<f16>) -> f16,
(vec4<f64>) -> f64,
],
conclude: Scalar,
}
DEBUG overloads after arg 0 of type vec2<f32>: List {
rules: [
(vec2<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG initial overloads for Saturate, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG var LocalVariable { name: Some("alpha"), ty: [0], init: None }
DEBUG initial overloads for Length: List {
rules: [
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<f32>) -> f32,
(vec2<f16>) -> f16,
(vec2<f64>) -> f64,
(vec3<f32>) -> f32,
(vec3<f16>) -> f16,
(vec3<f64>) -> f64,
(vec4<f32>) -> f32,
(vec4<f16>) -> f16,
(vec4<f64>) -> f64,
],
conclude: Scalar,
}
DEBUG overloads after arg 0: List {
rules: [
(vec2<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG initial overloads for Length: List {
rules: [
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<f32>) -> f32,
(vec2<f16>) -> f16,
(vec2<f64>) -> f64,
(vec3<f32>) -> f32,
(vec3<f16>) -> f16,
(vec3<f64>) -> f64,
(vec4<f32>) -> f32,
(vec4<f16>) -> f16,
(vec4<f64>) -> f64,
],
conclude: Scalar,
}
DEBUG overloads after arg 0: List {
rules: [
(vec2<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG initial overloads for Saturate: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG var LocalVariable { name: Some("out"), ty: [34], init: Some([26]) }
DEBUG var LocalVariable { name: Some("out"), ty: [37], init: Some([14]) }
DEBUG initial overloads for Sin, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Cos, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Sqrt, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Max, List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Saturate, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Sin: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Cos: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Sqrt: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Max: List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Saturate: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG var LocalVariable { name: Some("out"), ty: [40], init: Some([14]) }
DEBUG var LocalVariable { name: Some("out"), ty: [43], init: Some([14]) }
DEBUG initial overloads for Dot, List {
rules: [
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> {AbstractInt},
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> {AbstractFloat},
(vec2<i32>, vec2<i32>) -> i32,
(vec2<i64>, vec2<i64>) -> i64,
(vec2<u32>, vec2<u32>) -> u32,
(vec2<u64>, vec2<u64>) -> u64,
(vec2<f32>, vec2<f32>) -> f32,
(vec2<f16>, vec2<f16>) -> f16,
(vec2<f64>, vec2<f64>) -> f64,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> {AbstractInt},
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> {AbstractFloat},
(vec3<i32>, vec3<i32>) -> i32,
(vec3<i64>, vec3<i64>) -> i64,
(vec3<u32>, vec3<u32>) -> u32,
(vec3<u64>, vec3<u64>) -> u64,
(vec3<f32>, vec3<f32>) -> f32,
(vec3<f16>, vec3<f16>) -> f16,
(vec3<f64>, vec3<f64>) -> f64,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> {AbstractInt},
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> {AbstractFloat},
(vec4<i32>, vec4<i32>) -> i32,
(vec4<i64>, vec4<i64>) -> i64,
(vec4<u32>, vec4<u32>) -> u32,
(vec4<u64>, vec4<u64>) -> u64,
(vec4<f32>, vec4<f32>) -> f32,
(vec4<f16>, vec4<f16>) -> f16,
(vec4<f64>, vec4<f64>) -> f64,
],
conclude: Scalar,
}
DEBUG overloads after arg 0 of type vec3<f32>: List {
rules: [
(vec3<f32>, vec3<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG overloads after arg 1 of type vec3<f32>: List {
rules: [
(vec3<f32>, vec3<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG initial overloads for Saturate, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG var LocalVariable { name: Some("color"), ty: [2], init: None }
DEBUG initial overloads for Dot: List {
rules: [
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> {AbstractInt},
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> {AbstractFloat},
(vec2<i32>, vec2<i32>) -> i32,
(vec2<i64>, vec2<i64>) -> i64,
(vec2<u32>, vec2<u32>) -> u32,
(vec2<u64>, vec2<u64>) -> u64,
(vec2<f32>, vec2<f32>) -> f32,
(vec2<f16>, vec2<f16>) -> f16,
(vec2<f64>, vec2<f64>) -> f64,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> {AbstractInt},
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> {AbstractFloat},
(vec3<i32>, vec3<i32>) -> i32,
(vec3<i64>, vec3<i64>) -> i64,
(vec3<u32>, vec3<u32>) -> u32,
(vec3<u64>, vec3<u64>) -> u64,
(vec3<f32>, vec3<f32>) -> f32,
(vec3<f16>, vec3<f16>) -> f16,
(vec3<f64>, vec3<f64>) -> f64,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> {AbstractInt},
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> {AbstractFloat},
(vec4<i32>, vec4<i32>) -> i32,
(vec4<i64>, vec4<i64>) -> i64,
(vec4<u32>, vec4<u32>) -> u32,
(vec4<u64>, vec4<u64>) -> u64,
(vec4<f32>, vec4<f32>) -> f32,
(vec4<f16>, vec4<f16>) -> f16,
(vec4<f64>, vec4<f64>) -> f64,
],
conclude: Scalar,
}
DEBUG overloads after arg 0: List {
rules: [
(vec3<f32>, vec3<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG overloads after arg 1: List {
rules: [
(vec3<f32>, vec3<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG initial overloads for Saturate: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG var LocalVariable { name: Some("out"), ty: [46], init: Some([10]) }
INFO Skip function Some("to_tile_position")
INFO Skip function Some("to_tile_position")
INFO Skip function Some("to_tile_position")
INFO Skip function Some("to_tile_position")
INFO Skip function Some("to_tile_position")
INFO Skip function Some("to_device_position_impl")
INFO Skip function Some("to_device_position")
INFO Skip function Some("to_device_position_transformed")
INFO Skip function Some("to_tile_position")
INFO Skip function Some("blend_color")
INFO Skip function Some("to_tile_position")
INFO Skip function Some("to_device_position_impl")
INFO Skip function Some("to_device_position")
INFO Skip function Some("to_device_position_transformed")
INFO Skip function Some("to_tile_position")
INFO Skip function Some("blend_color")
INFO Skip function Some("to_tile_position")
INFO Skip function Some("to_tile_position")
INFO Skip function Some("to_tile_position")
INFO Skip function Some("to_tile_position")
INFO Skip function Some("to_tile_position")
INFO Skip function Some("to_device_position_impl")
INFO Skip function Some("to_device_position")
INFO Skip function Some("to_device_position_transformed")
INFO Skip function Some("to_tile_position")
INFO Skip function Some("blend_color")
INFO Creating texture 0x56390bb10800 of size 7680x4320x1 and format Bgra8Unorm, name 'path intermediate', handle 0
INFO Creating texture 0x56390bafb540 of size 7680x4320x1 and format Bgra8Unorm, name 'path intermediate msaa', handle 1
INFO Server-side decorations requested, but the Wayland server does not support them. Falling back to client-side decorations.
DEBUG font matches for Attrs { color_opt: None, family: Name("Ubuntu"), stretch: Normal, style: Normal, weight: Weight(400), metadata: 2, cache_key_flags: CacheKeyFlags(0x0), metrics_opt: None, letter_spacing_opt: None, font_features: FontFeatures { features: [] } } in 160.659µs
INFO Creating texture 0x56390bc57f00 of size 1024x1024x1 and format R8Unorm, name 'atlas', handle 2
INFO Creating buffer 0x56390ba3c430 of size 65536, name 'chunk-0', handle 3
INFO RPC{rpc.trace_id=00 rpc.deadline=2026-01-12T19:09:29.975123286Z otel.kind="server" otel.name="ZlaunchService.show"}: CompleteRequest
INFO RPC{rpc.trace_id=00 rpc.deadline=2026-01-12T19:09:29.975123286Z otel.kind="server" otel.name="ZlaunchService.show"}: BufferResponse
INFO RPC{rpc.trace_id=00 rpc.deadline=2026-01-12T19:09:29.975123286Z otel.kind="server" otel.name="ZlaunchService.show"}: SendResponse
INFO Using surface present mode MAILBOX
INFO Retaining current format: Bgra8Unorm
INFO Destroying texture 0x56390bb10800, handle 0
INFO Destroying texture 0x56390bafb540, handle 1
INFO Creating texture 0x56390bb10800 of size 1944x1064x1 and format Bgra8Unorm, name 'path intermediate', handle 1
INFO Creating texture 0x56390bafb540 of size 1944x1064x1 and format Bgra8Unorm, name 'path intermediate msaa', handle 0
INFO Creating texture 0x56390be36540 of size 1024x1024x1 and format Bgra8Unorm, name 'atlas', handle 4
INFO Creating buffer 0x56390bbc7d80 of size 262144, name 'chunk-1', handle 5
INFO Creating buffer 0x56390bb23460 of size 262144, name 'chunk-2', handle 6
INFO Creating buffer 0x56390bbcd170 of size 4096, name 'chunk-0', handle 7
INFO Creating buffer 0x56390be4d430 of size 4096, name 'chunk-1', handle 8
INFO Creating buffer 0x56390bb22fd0 of size 16016, name 'chunk-2', handle 9
INFO Creating buffer 0x56390be426e0 of size 4592, name 'chunk-3', handle 10
WARN Acquire failed because the surface is out of date
INFO Creating texture 0x56390be776d0 of size 2048x2048x1 and format Bgra8Unorm, name 'atlas', handle 11
INFO Creating buffer 0x56390bb3b7b0 of size 16777216, name 'chunk-3', handle 12
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
INFO Creating buffer 0x56390bab95b0 of size 19824, name 'chunk-4', handle 13
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
INFO Creating buffer 0x56390bb65fa0 of size 24640, name 'chunk-5', handle 14
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
WARN Acquire failed because the surface is out of date
INFO Destroying texture 0x56390bc57f00, handle 2
INFO Destroying texture 0x56390be36540, handle 4
INFO Destroying texture 0x56390be776d0, handle 11
INFO Destroying buffer 0x56390bb23460, handle 6
INFO Destroying buffer 0x56390ba3c430, handle 3
INFO Destroying buffer 0x56390bb3b7b0, handle 12
INFO Destroying buffer 0x56390bbc7d80, handle 5
INFO Destroying buffer 0x56390bb22fd0, handle 9
INFO Destroying buffer 0x56390bbcd170, handle 7
INFO Destroying buffer 0x56390bb65fa0, handle 14
INFO Destroying buffer 0x56390be4d430, handle 8
INFO Destroying buffer 0x56390bab95b0, handle 13
INFO Destroying buffer 0x56390be426e0, handle 10
INFO Destroying texture 0x56390bb10800, handle 1
INFO Destroying texture 0x56390bafb540, handle 0
ERROR window not found
Stack backtrace:
0: <gpui::app::async_context::AsyncApp as gpui::AppContext>::update_window
1: gpui::window::Window::new::{{closure}}
2: gpui::platform::linux::wayland::window::WaylandWindowStatePtr::frame
3: <gpui::platform::linux::wayland::client::WaylandClientStatePtr as wayland_client::event_queue::Dispatch<wayland_client::protocol::wl_callback::WlCallback,wayland_backend::sys::client::ObjectId>>::event
4: wayland_client::event_queue::queue_callback
5: wayland_client::event_queue::EventQueue<State>::dispatching_impl
6: <core::cell::RefCell<calloop::sources::DispatcherInner<S,F>> as calloop::sources::EventDispatcher<Data>>::process_events
7: <gpui::platform::linux::wayland::client::WaylandClient as gpui::platform::linux::platform::LinuxClient>::run
8: gpui::platform::linux::platform::<impl gpui::platform::Platform for P>::run
9: gpui::app::Application::run
10: zlaunch::daemon::run
11: std::sys::backtrace::__rust_begin_short_backtrace
12: std::rt::lang_start::{{closure}}
13: std::rt::lang_start_internal
14: main
15: <unknown>
16: __libc_start_main
17: _start
ERROR window not found
Stack backtrace:
0: <gpui::app::async_context::AsyncApp as gpui::AppContext>::update_window
1: gpui::window::Window::new::{{closure}}
2: gpui::platform::linux::wayland::window::WaylandWindowStatePtr::frame
3: <gpui::platform::linux::wayland::client::WaylandClientStatePtr as wayland_client::event_queue::Dispatch<wayland_client::protocol::wl_callback::WlCallback,wayland_backend::sys::client::ObjectId>>::event
4: wayland_client::event_queue::queue_callback
5: wayland_client::event_queue::EventQueue<State>::dispatching_impl
6: <core::cell::RefCell<calloop::sources::DispatcherInner<S,F>> as calloop::sources::EventDispatcher<Data>>::process_events
7: <gpui::platform::linux::wayland::client::WaylandClient as gpui::platform::linux::platform::LinuxClient>::run
8: gpui::platform::linux::platform::<impl gpui::platform::Platform for P>::run
9: gpui::app::Application::run
10: zlaunch::daemon::run
11: std::sys::backtrace::__rust_begin_short_backtrace
12: std::rt::lang_start::{{closure}}
13: std::rt::lang_start_internal
14: main
15: <unknown>
16: __libc_start_main
17: _start
ERROR window not found
Stack backtrace:
0: <gpui::app::async_context::AsyncApp as gpui::AppContext>::update_window
1: gpui::window::Window::new::{{closure}}
2: gpui::platform::linux::wayland::window::WaylandWindowStatePtr::frame
3: <gpui::platform::linux::wayland::client::WaylandClientStatePtr as wayland_client::event_queue::Dispatch<wayland_client::protocol::wl_callback::WlCallback,wayland_backend::sys::client::ObjectId>>::event
4: wayland_client::event_queue::queue_callback
5: wayland_client::event_queue::EventQueue<State>::dispatching_impl
6: <core::cell::RefCell<calloop::sources::DispatcherInner<S,F>> as calloop::sources::EventDispatcher<Data>>::process_events
7: <gpui::platform::linux::wayland::client::WaylandClient as gpui::platform::linux::platform::LinuxClient>::run
8: gpui::platform::linux::platform::<impl gpui::platform::Platform for P>::run
9: gpui::app::Application::run
10: zlaunch::daemon::run
11: std::sys::backtrace::__rust_begin_short_backtrace
12: std::rt::lang_start::{{closure}}
13: std::rt::lang_start_internal
14: main
15: <unknown>
16: __libc_start_main
17: _start
INFO RPC{rpc.trace_id=00 rpc.deadline=2026-01-12T19:09:59.853066020Z otel.kind="server"}: ReceiveRequest
INFO RPC{rpc.trace_id=00 rpc.deadline=2026-01-12T19:09:59.853066020Z otel.kind="server"}: BeginRequest
DEBUG SurfaceCapabilitiesKHR { min_image_count: 2, max_image_count: 8, current_extent: Extent2D { width: 4294967295, height: 4294967295 }, min_image_extent: Extent2D { width: 1, height: 1 }, max_image_extent: Extent2D { width: 16384, height: 16384 }, max_image_array_layers: 1, supported_transforms: IDENTITY, current_transform: IDENTITY, supported_composite_alpha: OPAQUE | PRE_MULTIPLIED, supported_usage_flags: TRANSFER_SRC | TRANSFER_DST | SAMPLED | STORAGE | COLOR_ATTACHMENT | INPUT_ATTACHMENT }
INFO Using surface present mode MAILBOX
INFO Creating a descriptor pool for at most 16 sets
INFO Creating a descriptor pool for at most 16 sets
INFO Initializing Blade pipelines for surface SurfaceInfo { format: Bgra8Unorm, alpha: PreMultiplied }
DEBUG Resolving [0] = FunctionArgument(0) : Handle([1])
DEBUG Resolving [1] = Literal(AbstractFloat(0.3)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [2] = Literal(AbstractFloat(0.59)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [3] = Literal(AbstractFloat(0.11)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [4] = Literal(F32(0.3)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [5] = Literal(F32(0.59)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [6] = Literal(F32(0.11)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [7] = Compose { ty: [1], components: [[4], [5], [6]] } : Handle([1])
DEBUG Initial overloads: List {
rules: [
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> {AbstractInt},
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> {AbstractFloat},
(vec2<i32>, vec2<i32>) -> i32,
(vec2<i64>, vec2<i64>) -> i64,
(vec2<u32>, vec2<u32>) -> u32,
(vec2<u64>, vec2<u64>) -> u64,
(vec2<f32>, vec2<f32>) -> f32,
(vec2<f16>, vec2<f16>) -> f16,
(vec2<f64>, vec2<f64>) -> f64,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> {AbstractInt},
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> {AbstractFloat},
(vec3<i32>, vec3<i32>) -> i32,
(vec3<i64>, vec3<i64>) -> i64,
(vec3<u32>, vec3<u32>) -> u32,
(vec3<u64>, vec3<u64>) -> u64,
(vec3<f32>, vec3<f32>) -> f32,
(vec3<f16>, vec3<f16>) -> f16,
(vec3<f64>, vec3<f64>) -> f64,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> {AbstractInt},
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> {AbstractFloat},
(vec4<i32>, vec4<i32>) -> i32,
(vec4<i64>, vec4<i64>) -> i64,
(vec4<u32>, vec4<u32>) -> u32,
(vec4<u64>, vec4<u64>) -> u64,
(vec4<f32>, vec4<f32>) -> f32,
(vec4<f16>, vec4<f16>) -> f16,
(vec4<f64>, vec4<f64>) -> f64,
],
conclude: Scalar,
}
DEBUG Supplying argument 0 of type vec3<f32>
DEBUG Remaining overloads: List {
rules: [
(vec3<f32>, vec3<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG Supplying argument 1 of type vec3<f32>
DEBUG Remaining overloads: List {
rules: [
(vec3<f32>, vec3<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG initial overloads for Dot, List {
rules: [
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> {AbstractInt},
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> {AbstractFloat},
(vec2<i32>, vec2<i32>) -> i32,
(vec2<i64>, vec2<i64>) -> i64,
(vec2<u32>, vec2<u32>) -> u32,
(vec2<u64>, vec2<u64>) -> u64,
(vec2<f32>, vec2<f32>) -> f32,
(vec2<f16>, vec2<f16>) -> f16,
(vec2<f64>, vec2<f64>) -> f64,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> {AbstractInt},
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> {AbstractFloat},
(vec3<i32>, vec3<i32>) -> i32,
(vec3<i64>, vec3<i64>) -> i64,
(vec3<u32>, vec3<u32>) -> u32,
(vec3<u64>, vec3<u64>) -> u64,
(vec3<f32>, vec3<f32>) -> f32,
(vec3<f16>, vec3<f16>) -> f16,
(vec3<f64>, vec3<f64>) -> f64,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> {AbstractInt},
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> {AbstractFloat},
(vec4<i32>, vec4<i32>) -> i32,
(vec4<i64>, vec4<i64>) -> i64,
(vec4<u32>, vec4<u32>) -> u32,
(vec4<u64>, vec4<u64>) -> u64,
(vec4<f32>, vec4<f32>) -> f32,
(vec4<f16>, vec4<f16>) -> f16,
(vec4<f64>, vec4<f64>) -> f64,
],
conclude: Scalar,
}
DEBUG overloads after arg 0 of type vec3<f32>: List {
rules: [
(vec3<f32>, vec3<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG overloads after arg 1 of type vec3<f32>: List {
rules: [
(vec3<f32>, vec3<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG Resolving [8] = Math { fun: Dot, arg: [0], arg1: Some([7]), arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [0] = FunctionArgument(0) : Handle([0])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([1])
DEBUG Resolving [2] = CallResult([0]) : Handle([0])
DEBUG Resolving [3] = Literal(AbstractFloat(4.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [4] = Literal(AbstractFloat(0.75)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [5] = Literal(F32(0.75)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [6] = Binary { op: Subtract, left: [5], right: [2] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [7] = Literal(F32(4.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [8] = Binary { op: Multiply, left: [7], right: [6] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Saturate, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [9] = Math { fun: Saturate, arg: [8], arg1: None, arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [10] = Binary { op: Multiply, left: [0], right: [9] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [0] = FunctionArgument(0) : Handle([0])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([0])
DEBUG Resolving [2] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [3] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [4] = Binary { op: Add, left: [1], right: [3] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [5] = Binary { op: Multiply, left: [0], right: [4] } : Handle([0])
DEBUG Resolving [6] = Binary { op: Multiply, left: [0], right: [1] } : Handle([0])
DEBUG Resolving [7] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [8] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [9] = Binary { op: Add, left: [6], right: [8] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [10] = Binary { op: Divide, left: [5], right: [9] } : Handle([0])
DEBUG Resolving [0] = FunctionArgument(0) : Handle([0])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([0])
DEBUG Resolving [2] = FunctionArgument(2) : Handle([2])
DEBUG Resolving [3] = AccessIndex { base: [2], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [4] = Binary { op: Multiply, left: [3], right: [1] } : Handle([0])
DEBUG Resolving [5] = AccessIndex { base: [2], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [6] = Binary { op: Add, left: [4], right: [5] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [7] = Binary { op: Multiply, left: [6], right: [0] } : Handle([0])
DEBUG Resolving [8] = AccessIndex { base: [2], index: 2 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [9] = Binary { op: Multiply, left: [8], right: [1] } : Handle([0])
DEBUG Resolving [10] = AccessIndex { base: [2], index: 3 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [11] = Binary { op: Add, left: [9], right: [10] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [12] = Binary { op: Add, left: [7], right: [11] } : Handle([0])
DEBUG Resolving [13] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [14] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [15] = Binary { op: Subtract, left: [14], right: [0] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [16] = Binary { op: Multiply, left: [0], right: [15] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [17] = Binary { op: Multiply, left: [16], right: [12] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [18] = Binary { op: Add, left: [0], right: [17] } : Handle([0])
DEBUG Resolving [0] = FunctionArgument(0) : Handle([0])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([1])
DEBUG Resolving [2] = FunctionArgument(2) : Handle([0])
DEBUG Resolving [3] = FunctionArgument(3) : Handle([2])
DEBUG Resolving [4] = CallResult([1]) : Handle([0])
DEBUG Resolving [5] = CallResult([0]) : Handle([0])
DEBUG Resolving [6] = CallResult([2]) : Handle([0])
DEBUG Resolving [7] = CallResult([3]) : Handle([0])
DEBUG Resolving [0] = Literal(AbstractFloat(3.1415926)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [1] = Literal(F32(3.1415925)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [2] = Literal(AbstractFloat(0.2126)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [3] = Literal(AbstractFloat(0.7152)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [4] = Literal(AbstractFloat(0.0722)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [5] = Literal(F32(0.2126)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [6] = Literal(F32(0.7152)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [7] = Literal(F32(0.0722)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [8] = Compose { ty: [1], components: [[5], [6], [7]] } : Handle([1])
DEBUG Resolving [9] = Literal(AbstractInt(2)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [0] = FunctionArgument(0) : Handle([3])
DEBUG Resolving [1] = GlobalVariable([0]) : Value(Pointer { base: [5], space: Uniform })
DEBUG Resolving [2] = AccessIndex { base: [1], index: 0 } : Value(Pointer { base: [3], space: Uniform })
DEBUG Resolving [3] = Load { pointer: [2] } : Handle([3])
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [4] = Binary { op: Divide, left: [0], right: [3] } : Handle([3])
DEBUG Resolving [5] = Literal(AbstractFloat(2.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [6] = Literal(AbstractFloat(2.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [7] = Literal(AbstractFloat(-2.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [8] = Literal(F32(2.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [9] = Literal(F32(-2.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [10] = Compose { ty: [3], components: [[8], [9]] } : Handle([3])
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [11] = Binary { op: Multiply, left: [4], right: [10] } : Handle([3])
DEBUG Resolving [12] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [13] = Literal(AbstractFloat(-1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [14] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [15] = Literal(F32(-1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [16] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [17] = Compose { ty: [3], components: [[15], [16]] } : Handle([3])
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [18] = Binary { op: Add, left: [11], right: [17] } : Handle([3])
DEBUG Resolving [19] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [20] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [21] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [22] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [23] = Compose { ty: [2], components: [[18], [21], [22]] } : Handle([2])
DEBUG Resolving [0] = FunctionArgument(0) : Handle([3])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([8])
DEBUG Resolving [2] = AccessIndex { base: [1], index: 1 } : Handle([3])
DEBUG Resolving [3] = As { expr: [2], kind: Float, convert: Some(4) } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [4] = Binary { op: Multiply, left: [0], right: [3] } : Handle([3])
DEBUG Resolving [5] = AccessIndex { base: [1], index: 0 } : Handle([3])
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [6] = Binary { op: Add, left: [4], right: [5] } : Handle([3])
DEBUG Resolving [7] = CallResult([5]) : Handle([2])
DEBUG Resolving [0] = FunctionArgument(0) : Handle([3])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([8])
DEBUG Resolving [2] = FunctionArgument(2) : Handle([21])
DEBUG Resolving [3] = AccessIndex { base: [1], index: 1 } : Handle([3])
DEBUG Resolving [4] = As { expr: [3], kind: Float, convert: Some(4) } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [5] = Binary { op: Multiply, left: [0], right: [4] } : Handle([3])
DEBUG Resolving [6] = AccessIndex { base: [1], index: 0 } : Handle([3])
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [7] = Binary { op: Add, left: [5], right: [6] } : Handle([3])
DEBUG Resolving [8] = AccessIndex { base: [2], index: 0 } : Handle([20])
DEBUG Initial overloads: [
(mat2x2<{AbstractFloat}>) -> mat2x2<{AbstractFloat}>,
(mat2x2<f32>) -> mat2x2<f32>,
(mat2x2<f16>) -> mat2x2<f16>,
(mat2x2<f64>) -> mat2x2<f64>,
(mat2x3<{AbstractFloat}>) -> mat3x2<{AbstractFloat}>,
(mat2x3<f32>) -> mat3x2<f32>,
(mat2x3<f16>) -> mat3x2<f16>,
(mat2x3<f64>) -> mat3x2<f64>,
(mat2x4<{AbstractFloat}>) -> mat4x2<{AbstractFloat}>,
(mat2x4<f32>) -> mat4x2<f32>,
(mat2x4<f16>) -> mat4x2<f16>,
(mat2x4<f64>) -> mat4x2<f64>,
(mat3x2<{AbstractFloat}>) -> mat2x3<{AbstractFloat}>,
(mat3x2<f32>) -> mat2x3<f32>,
(mat3x2<f16>) -> mat2x3<f16>,
(mat3x2<f64>) -> mat2x3<f64>,
(mat3x3<{AbstractFloat}>) -> mat3x3<{AbstractFloat}>,
(mat3x3<f32>) -> mat3x3<f32>,
(mat3x3<f16>) -> mat3x3<f16>,
(mat3x3<f64>) -> mat3x3<f64>,
(mat3x4<{AbstractFloat}>) -> mat4x3<{AbstractFloat}>,
(mat3x4<f32>) -> mat4x3<f32>,
(mat3x4<f16>) -> mat4x3<f16>,
(mat3x4<f64>) -> mat4x3<f64>,
(mat4x2<{AbstractFloat}>) -> mat2x4<{AbstractFloat}>,
(mat4x2<f32>) -> mat2x4<f32>,
(mat4x2<f16>) -> mat2x4<f16>,
(mat4x2<f64>) -> mat2x4<f64>,
(mat4x3<{AbstractFloat}>) -> mat3x4<{AbstractFloat}>,
(mat4x3<f32>) -> mat3x4<f32>,
(mat4x3<f16>) -> mat3x4<f16>,
(mat4x3<f64>) -> mat3x4<f64>,
(mat4x4<{AbstractFloat}>) -> mat4x4<{AbstractFloat}>,
(mat4x4<f32>) -> mat4x4<f32>,
(mat4x4<f16>) -> mat4x4<f16>,
(mat4x4<f64>) -> mat4x4<f64>,
]
DEBUG Supplying argument 0 of type mat2x2<f32>
DEBUG arg 0 of type mat2x2<f32>
DEBUG considering rule (mat2x2<{AbstractFloat}>) -> mat2x2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat2x2<f32>) -> mat2x2<f32>
DEBUG types are equivalent
DEBUG considering rule (mat2x2<f16>) -> mat2x2<f16>
DEBUG no conversion possible
DEBUG considering rule (mat2x2<f64>) -> mat2x2<f64>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<{AbstractFloat}>) -> mat3x2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<f32>) -> mat3x2<f32>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<f16>) -> mat3x2<f16>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<f64>) -> mat3x2<f64>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<{AbstractFloat}>) -> mat4x2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<f32>) -> mat4x2<f32>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<f16>) -> mat4x2<f16>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<f64>) -> mat4x2<f64>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<{AbstractFloat}>) -> mat2x3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<f32>) -> mat2x3<f32>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<f16>) -> mat2x3<f16>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<f64>) -> mat2x3<f64>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<{AbstractFloat}>) -> mat3x3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<f32>) -> mat3x3<f32>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<f16>) -> mat3x3<f16>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<f64>) -> mat3x3<f64>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<{AbstractFloat}>) -> mat4x3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<f32>) -> mat4x3<f32>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<f16>) -> mat4x3<f16>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<f64>) -> mat4x3<f64>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<{AbstractFloat}>) -> mat2x4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<f32>) -> mat2x4<f32>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<f16>) -> mat2x4<f16>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<f64>) -> mat2x4<f64>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<{AbstractFloat}>) -> mat3x4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<f32>) -> mat3x4<f32>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<f16>) -> mat3x4<f16>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<f64>) -> mat3x4<f64>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<{AbstractFloat}>) -> mat4x4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<f32>) -> mat4x4<f32>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<f16>) -> mat4x4<f16>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<f64>) -> mat4x4<f64>
DEBUG no conversion possible
DEBUG Remaining overloads: [
(mat2x2<f32>) -> mat2x2<f32>,
]
DEBUG initial overloads for Transpose, [
(mat2x2<{AbstractFloat}>) -> mat2x2<{AbstractFloat}>,
(mat2x2<f32>) -> mat2x2<f32>,
(mat2x2<f16>) -> mat2x2<f16>,
(mat2x2<f64>) -> mat2x2<f64>,
(mat2x3<{AbstractFloat}>) -> mat3x2<{AbstractFloat}>,
(mat2x3<f32>) -> mat3x2<f32>,
(mat2x3<f16>) -> mat3x2<f16>,
(mat2x3<f64>) -> mat3x2<f64>,
(mat2x4<{AbstractFloat}>) -> mat4x2<{AbstractFloat}>,
(mat2x4<f32>) -> mat4x2<f32>,
(mat2x4<f16>) -> mat4x2<f16>,
(mat2x4<f64>) -> mat4x2<f64>,
(mat3x2<{AbstractFloat}>) -> mat2x3<{AbstractFloat}>,
(mat3x2<f32>) -> mat2x3<f32>,
(mat3x2<f16>) -> mat2x3<f16>,
(mat3x2<f64>) -> mat2x3<f64>,
(mat3x3<{AbstractFloat}>) -> mat3x3<{AbstractFloat}>,
(mat3x3<f32>) -> mat3x3<f32>,
(mat3x3<f16>) -> mat3x3<f16>,
(mat3x3<f64>) -> mat3x3<f64>,
(mat3x4<{AbstractFloat}>) -> mat4x3<{AbstractFloat}>,
(mat3x4<f32>) -> mat4x3<f32>,
(mat3x4<f16>) -> mat4x3<f16>,
(mat3x4<f64>) -> mat4x3<f64>,
(mat4x2<{AbstractFloat}>) -> mat2x4<{AbstractFloat}>,
(mat4x2<f32>) -> mat2x4<f32>,
(mat4x2<f16>) -> mat2x4<f16>,
(mat4x2<f64>) -> mat2x4<f64>,
(mat4x3<{AbstractFloat}>) -> mat3x4<{AbstractFloat}>,
(mat4x3<f32>) -> mat3x4<f32>,
(mat4x3<f16>) -> mat3x4<f16>,
(mat4x3<f64>) -> mat3x4<f64>,
(mat4x4<{AbstractFloat}>) -> mat4x4<{AbstractFloat}>,
(mat4x4<f32>) -> mat4x4<f32>,
(mat4x4<f16>) -> mat4x4<f16>,
(mat4x4<f64>) -> mat4x4<f64>,
]
DEBUG arg 0 of type mat2x2<f32>
DEBUG considering rule (mat2x2<{AbstractFloat}>) -> mat2x2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat2x2<f32>) -> mat2x2<f32>
DEBUG types are equivalent
DEBUG considering rule (mat2x2<f16>) -> mat2x2<f16>
DEBUG no conversion possible
DEBUG considering rule (mat2x2<f64>) -> mat2x2<f64>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<{AbstractFloat}>) -> mat3x2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<f32>) -> mat3x2<f32>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<f16>) -> mat3x2<f16>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<f64>) -> mat3x2<f64>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<{AbstractFloat}>) -> mat4x2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<f32>) -> mat4x2<f32>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<f16>) -> mat4x2<f16>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<f64>) -> mat4x2<f64>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<{AbstractFloat}>) -> mat2x3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<f32>) -> mat2x3<f32>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<f16>) -> mat2x3<f16>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<f64>) -> mat2x3<f64>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<{AbstractFloat}>) -> mat3x3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<f32>) -> mat3x3<f32>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<f16>) -> mat3x3<f16>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<f64>) -> mat3x3<f64>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<{AbstractFloat}>) -> mat4x3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<f32>) -> mat4x3<f32>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<f16>) -> mat4x3<f16>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<f64>) -> mat4x3<f64>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<{AbstractFloat}>) -> mat2x4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<f32>) -> mat2x4<f32>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<f16>) -> mat2x4<f16>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<f64>) -> mat2x4<f64>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<{AbstractFloat}>) -> mat3x4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<f32>) -> mat3x4<f32>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<f16>) -> mat3x4<f16>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<f64>) -> mat3x4<f64>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<{AbstractFloat}>) -> mat4x4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<f32>) -> mat4x4<f32>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<f16>) -> mat4x4<f16>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<f64>) -> mat4x4<f64>
DEBUG no conversion possible
DEBUG overloads after arg 0 of type mat2x2<f32>: [
(mat2x2<f32>) -> mat2x2<f32>,
]
DEBUG Resolving [9] = Math { fun: Transpose, arg: [8], arg1: None, arg2: None, arg3: None } : Value(Matrix { columns: Bi, rows: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: mat2x2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [10] = Binary { op: Multiply, left: [9], right: [7] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [11] = AccessIndex { base: [2], index: 1 } : Handle([3])
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [12] = Binary { op: Add, left: [10], right: [11] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [13] = CallResult([5]) : Handle([2])
DEBUG Resolving [0] = FunctionArgument(0) : Handle([3])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([19])
DEBUG Resolving [2] = GlobalVariable([3]) : Handle([6])
DEBUG Resolving [3] = Literal(AbstractInt(0)) : Value(Scalar(Scalar { kind: AbstractInt, width: 8 }))
DEBUG Resolving [4] = Literal(I32(0)) : Value(Scalar(Scalar { kind: Sint, width: 4 }))
DEBUG Resolving [5] = ImageQuery { image: [2], query: Size { level: Some([4]) } } : Value(Vector { size: Bi, scalar: Scalar { kind: Uint, width: 4 } })
DEBUG Resolving [6] = As { expr: [5], kind: Float, convert: Some(4) } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [7] = AccessIndex { base: [1], index: 3 } : Handle([18])
DEBUG Resolving [8] = AccessIndex { base: [7], index: 0 } : Handle([17])
DEBUG Resolving [9] = As { expr: [8], kind: Float, convert: Some(4) } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [10] = AccessIndex { base: [1], index: 3 } : Handle([18])
DEBUG Resolving [11] = AccessIndex { base: [10], index: 1 } : Handle([17])
DEBUG Resolving [12] = As { expr: [11], kind: Float, convert: Some(4) } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [13] = Binary { op: Multiply, left: [0], right: [12] } : Handle([3])
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [14] = Binary { op: Add, left: [9], right: [13] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [15] = Binary { op: Divide, left: [14], right: [6] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [0] = FunctionArgument(0) : Handle([3])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([8])
DEBUG Resolving [2] = AccessIndex { base: [1], index: 0 } : Handle([3])
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [3] = Binary { op: Subtract, left: [0], right: [2] } : Handle([3])
DEBUG Resolving [4] = AccessIndex { base: [1], index: 0 } : Handle([3])
DEBUG Resolving [5] = AccessIndex { base: [1], index: 1 } : Handle([3])
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [6] = Binary { op: Add, left: [4], right: [5] } : Handle([3])
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [7] = Binary { op: Subtract, left: [6], right: [0] } : Handle([3])
DEBUG Resolving [8] = AccessIndex { base: [3], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [9] = AccessIndex { base: [7], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [10] = AccessIndex { base: [3], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [11] = AccessIndex { base: [7], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [12] = Compose { ty: [2], components: [[8], [9], [10], [11]] } : Handle([2])
DEBUG Resolving [0] = FunctionArgument(0) : Handle([3])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([8])
DEBUG Resolving [2] = FunctionArgument(2) : Handle([8])
DEBUG Resolving [3] = AccessIndex { base: [1], index: 1 } : Handle([3])
DEBUG Resolving [4] = As { expr: [3], kind: Float, convert: Some(4) } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [5] = Binary { op: Multiply, left: [0], right: [4] } : Handle([3])
DEBUG Resolving [6] = AccessIndex { base: [1], index: 0 } : Handle([3])
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [7] = Binary { op: Add, left: [5], right: [6] } : Handle([3])
DEBUG Resolving [8] = CallResult([9]) : Handle([2])
DEBUG Resolving [0] = FunctionArgument(0) : Handle([3])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([8])
DEBUG Resolving [2] = FunctionArgument(2) : Handle([8])
DEBUG Resolving [3] = FunctionArgument(3) : Handle([21])
DEBUG Resolving [4] = AccessIndex { base: [1], index: 1 } : Handle([3])
DEBUG Resolving [5] = As { expr: [4], kind: Float, convert: Some(4) } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [6] = Binary { op: Multiply, left: [0], right: [5] } : Handle([3])
DEBUG Resolving [7] = AccessIndex { base: [1], index: 0 } : Handle([3])
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [8] = Binary { op: Add, left: [6], right: [7] } : Handle([3])
DEBUG Resolving [9] = AccessIndex { base: [3], index: 0 } : Handle([20])
DEBUG Initial overloads: [
(mat2x2<{AbstractFloat}>) -> mat2x2<{AbstractFloat}>,
(mat2x2<f32>) -> mat2x2<f32>,
(mat2x2<f16>) -> mat2x2<f16>,
(mat2x2<f64>) -> mat2x2<f64>,
(mat2x3<{AbstractFloat}>) -> mat3x2<{AbstractFloat}>,
(mat2x3<f32>) -> mat3x2<f32>,
(mat2x3<f16>) -> mat3x2<f16>,
(mat2x3<f64>) -> mat3x2<f64>,
(mat2x4<{AbstractFloat}>) -> mat4x2<{AbstractFloat}>,
(mat2x4<f32>) -> mat4x2<f32>,
(mat2x4<f16>) -> mat4x2<f16>,
(mat2x4<f64>) -> mat4x2<f64>,
(mat3x2<{AbstractFloat}>) -> mat2x3<{AbstractFloat}>,
(mat3x2<f32>) -> mat2x3<f32>,
(mat3x2<f16>) -> mat2x3<f16>,
(mat3x2<f64>) -> mat2x3<f64>,
(mat3x3<{AbstractFloat}>) -> mat3x3<{AbstractFloat}>,
(mat3x3<f32>) -> mat3x3<f32>,
(mat3x3<f16>) -> mat3x3<f16>,
(mat3x3<f64>) -> mat3x3<f64>,
(mat3x4<{AbstractFloat}>) -> mat4x3<{AbstractFloat}>,
(mat3x4<f32>) -> mat4x3<f32>,
(mat3x4<f16>) -> mat4x3<f16>,
(mat3x4<f64>) -> mat4x3<f64>,
(mat4x2<{AbstractFloat}>) -> mat2x4<{AbstractFloat}>,
(mat4x2<f32>) -> mat2x4<f32>,
(mat4x2<f16>) -> mat2x4<f16>,
(mat4x2<f64>) -> mat2x4<f64>,
(mat4x3<{AbstractFloat}>) -> mat3x4<{AbstractFloat}>,
(mat4x3<f32>) -> mat3x4<f32>,
(mat4x3<f16>) -> mat3x4<f16>,
(mat4x3<f64>) -> mat3x4<f64>,
(mat4x4<{AbstractFloat}>) -> mat4x4<{AbstractFloat}>,
(mat4x4<f32>) -> mat4x4<f32>,
(mat4x4<f16>) -> mat4x4<f16>,
(mat4x4<f64>) -> mat4x4<f64>,
]
DEBUG Supplying argument 0 of type mat2x2<f32>
DEBUG arg 0 of type mat2x2<f32>
DEBUG considering rule (mat2x2<{AbstractFloat}>) -> mat2x2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat2x2<f32>) -> mat2x2<f32>
DEBUG types are equivalent
DEBUG considering rule (mat2x2<f16>) -> mat2x2<f16>
DEBUG no conversion possible
DEBUG considering rule (mat2x2<f64>) -> mat2x2<f64>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<{AbstractFloat}>) -> mat3x2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<f32>) -> mat3x2<f32>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<f16>) -> mat3x2<f16>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<f64>) -> mat3x2<f64>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<{AbstractFloat}>) -> mat4x2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<f32>) -> mat4x2<f32>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<f16>) -> mat4x2<f16>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<f64>) -> mat4x2<f64>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<{AbstractFloat}>) -> mat2x3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<f32>) -> mat2x3<f32>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<f16>) -> mat2x3<f16>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<f64>) -> mat2x3<f64>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<{AbstractFloat}>) -> mat3x3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<f32>) -> mat3x3<f32>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<f16>) -> mat3x3<f16>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<f64>) -> mat3x3<f64>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<{AbstractFloat}>) -> mat4x3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<f32>) -> mat4x3<f32>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<f16>) -> mat4x3<f16>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<f64>) -> mat4x3<f64>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<{AbstractFloat}>) -> mat2x4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<f32>) -> mat2x4<f32>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<f16>) -> mat2x4<f16>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<f64>) -> mat2x4<f64>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<{AbstractFloat}>) -> mat3x4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<f32>) -> mat3x4<f32>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<f16>) -> mat3x4<f16>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<f64>) -> mat3x4<f64>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<{AbstractFloat}>) -> mat4x4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<f32>) -> mat4x4<f32>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<f16>) -> mat4x4<f16>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<f64>) -> mat4x4<f64>
DEBUG no conversion possible
DEBUG Remaining overloads: [
(mat2x2<f32>) -> mat2x2<f32>,
]
DEBUG initial overloads for Transpose, [
(mat2x2<{AbstractFloat}>) -> mat2x2<{AbstractFloat}>,
(mat2x2<f32>) -> mat2x2<f32>,
(mat2x2<f16>) -> mat2x2<f16>,
(mat2x2<f64>) -> mat2x2<f64>,
(mat2x3<{AbstractFloat}>) -> mat3x2<{AbstractFloat}>,
(mat2x3<f32>) -> mat3x2<f32>,
(mat2x3<f16>) -> mat3x2<f16>,
(mat2x3<f64>) -> mat3x2<f64>,
(mat2x4<{AbstractFloat}>) -> mat4x2<{AbstractFloat}>,
(mat2x4<f32>) -> mat4x2<f32>,
(mat2x4<f16>) -> mat4x2<f16>,
(mat2x4<f64>) -> mat4x2<f64>,
(mat3x2<{AbstractFloat}>) -> mat2x3<{AbstractFloat}>,
(mat3x2<f32>) -> mat2x3<f32>,
(mat3x2<f16>) -> mat2x3<f16>,
(mat3x2<f64>) -> mat2x3<f64>,
(mat3x3<{AbstractFloat}>) -> mat3x3<{AbstractFloat}>,
(mat3x3<f32>) -> mat3x3<f32>,
(mat3x3<f16>) -> mat3x3<f16>,
(mat3x3<f64>) -> mat3x3<f64>,
(mat3x4<{AbstractFloat}>) -> mat4x3<{AbstractFloat}>,
(mat3x4<f32>) -> mat4x3<f32>,
(mat3x4<f16>) -> mat4x3<f16>,
(mat3x4<f64>) -> mat4x3<f64>,
(mat4x2<{AbstractFloat}>) -> mat2x4<{AbstractFloat}>,
(mat4x2<f32>) -> mat2x4<f32>,
(mat4x2<f16>) -> mat2x4<f16>,
(mat4x2<f64>) -> mat2x4<f64>,
(mat4x3<{AbstractFloat}>) -> mat3x4<{AbstractFloat}>,
(mat4x3<f32>) -> mat3x4<f32>,
(mat4x3<f16>) -> mat3x4<f16>,
(mat4x3<f64>) -> mat3x4<f64>,
(mat4x4<{AbstractFloat}>) -> mat4x4<{AbstractFloat}>,
(mat4x4<f32>) -> mat4x4<f32>,
(mat4x4<f16>) -> mat4x4<f16>,
(mat4x4<f64>) -> mat4x4<f64>,
]
DEBUG arg 0 of type mat2x2<f32>
DEBUG considering rule (mat2x2<{AbstractFloat}>) -> mat2x2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat2x2<f32>) -> mat2x2<f32>
DEBUG types are equivalent
DEBUG considering rule (mat2x2<f16>) -> mat2x2<f16>
DEBUG no conversion possible
DEBUG considering rule (mat2x2<f64>) -> mat2x2<f64>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<{AbstractFloat}>) -> mat3x2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<f32>) -> mat3x2<f32>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<f16>) -> mat3x2<f16>
DEBUG no conversion possible
DEBUG considering rule (mat2x3<f64>) -> mat3x2<f64>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<{AbstractFloat}>) -> mat4x2<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<f32>) -> mat4x2<f32>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<f16>) -> mat4x2<f16>
DEBUG no conversion possible
DEBUG considering rule (mat2x4<f64>) -> mat4x2<f64>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<{AbstractFloat}>) -> mat2x3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<f32>) -> mat2x3<f32>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<f16>) -> mat2x3<f16>
DEBUG no conversion possible
DEBUG considering rule (mat3x2<f64>) -> mat2x3<f64>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<{AbstractFloat}>) -> mat3x3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<f32>) -> mat3x3<f32>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<f16>) -> mat3x3<f16>
DEBUG no conversion possible
DEBUG considering rule (mat3x3<f64>) -> mat3x3<f64>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<{AbstractFloat}>) -> mat4x3<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<f32>) -> mat4x3<f32>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<f16>) -> mat4x3<f16>
DEBUG no conversion possible
DEBUG considering rule (mat3x4<f64>) -> mat4x3<f64>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<{AbstractFloat}>) -> mat2x4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<f32>) -> mat2x4<f32>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<f16>) -> mat2x4<f16>
DEBUG no conversion possible
DEBUG considering rule (mat4x2<f64>) -> mat2x4<f64>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<{AbstractFloat}>) -> mat3x4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<f32>) -> mat3x4<f32>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<f16>) -> mat3x4<f16>
DEBUG no conversion possible
DEBUG considering rule (mat4x3<f64>) -> mat3x4<f64>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<{AbstractFloat}>) -> mat4x4<{AbstractFloat}>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<f32>) -> mat4x4<f32>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<f16>) -> mat4x4<f16>
DEBUG no conversion possible
DEBUG considering rule (mat4x4<f64>) -> mat4x4<f64>
DEBUG no conversion possible
DEBUG overloads after arg 0 of type mat2x2<f32>: [
(mat2x2<f32>) -> mat2x2<f32>,
]
DEBUG Resolving [10] = Math { fun: Transpose, arg: [9], arg1: None, arg2: None, arg3: None } : Value(Matrix { columns: Bi, rows: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: mat2x2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [11] = Binary { op: Multiply, left: [10], right: [8] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [12] = AccessIndex { base: [3], index: 1 } : Handle([3])
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [13] = Binary { op: Add, left: [11], right: [12] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [14] = CallResult([9]) : Handle([2])
DEBUG Resolving [0] = FunctionArgument(0) : Handle([1])
DEBUG Resolving [1] = Literal(AbstractFloat(0.04045)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [2] = Literal(F32(0.04045)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [3] = Splat { size: Tri, value: [2] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec3<f32>, vec3<f32>
DEBUG consensus: f32
DEBUG Resolving [4] = Binary { op: Less, left: [0], right: [3] } : Value(Vector { size: Tri, scalar: Scalar { kind: Bool, width: 1 } })
DEBUG Resolving [5] = Literal(AbstractFloat(0.055)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [6] = Literal(F32(0.055)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [7] = Splat { size: Tri, value: [6] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec3<f32>, vec3<f32>
DEBUG consensus: f32
DEBUG Resolving [8] = Binary { op: Add, left: [0], right: [7] } : Handle([1])
DEBUG Resolving [9] = Literal(AbstractFloat(1.055)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [10] = Literal(F32(1.055)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [11] = Splat { size: Tri, value: [10] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec3<f32>, vec3<f32>
DEBUG consensus: f32
DEBUG Resolving [12] = Binary { op: Divide, left: [8], right: [11] } : Handle([1])
DEBUG Resolving [13] = Literal(AbstractFloat(2.4)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [14] = Literal(F32(2.4)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [15] = Splat { size: Tri, value: [14] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type vec3<f32>
DEBUG Remaining overloads: List {
rules: [
(vec3<f32>, vec3<f32>) -> vec3<f32>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 1 of type vec3<f32>
DEBUG Remaining overloads: List {
rules: [
(vec3<f32>, vec3<f32>) -> vec3<f32>,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Pow, List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type vec3<f32>: List {
rules: [
(vec3<f32>, vec3<f32>) -> vec3<f32>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type vec3<f32>: List {
rules: [
(vec3<f32>, vec3<f32>) -> vec3<f32>,
],
conclude: ArgumentType,
}
DEBUG Resolving [16] = Math { fun: Pow, arg: [12], arg1: Some([15]), arg2: None, arg3: None } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [17] = Literal(AbstractFloat(12.92)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [18] = Literal(F32(12.92)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [19] = Splat { size: Tri, value: [18] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec3<f32>, vec3<f32>
DEBUG consensus: f32
DEBUG Resolving [20] = Binary { op: Divide, left: [0], right: [19] } : Handle([1])
DEBUG Resolving [21] = Select { condition: [4], accept: [20], reject: [16] } : Handle([1])
DEBUG Resolving [0] = FunctionArgument(0) : Handle([0])
DEBUG Resolving [1] = Literal(AbstractFloat(0.04045)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [2] = Literal(F32(0.04045)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [3] = Binary { op: Less, left: [0], right: [2] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [4] = Literal(AbstractFloat(0.055)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [5] = Literal(F32(0.055)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [6] = Binary { op: Add, left: [0], right: [5] } : Handle([0])
DEBUG Resolving [7] = Literal(AbstractFloat(1.055)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [8] = Literal(F32(1.055)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [9] = Binary { op: Divide, left: [6], right: [8] } : Handle([0])
DEBUG Resolving [10] = Literal(AbstractFloat(2.4)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 1 of type {AbstractFloat}
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [11] = Literal(F32(2.4)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG initial overloads for Pow, List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [12] = Math { fun: Pow, arg: [9], arg1: Some([11]), arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [13] = Literal(AbstractFloat(12.92)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [14] = Literal(F32(12.92)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [15] = Binary { op: Divide, left: [0], right: [14] } : Handle([0])
DEBUG Resolving [16] = Select { condition: [3], accept: [15], reject: [12] } : Handle([0])
DEBUG Resolving [0] = FunctionArgument(0) : Handle([1])
DEBUG Resolving [1] = Literal(AbstractFloat(0.0031308)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [2] = Literal(F32(0.0031308)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [3] = Splat { size: Tri, value: [2] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec3<f32>, vec3<f32>
DEBUG consensus: f32
DEBUG Resolving [4] = Binary { op: Less, left: [0], right: [3] } : Value(Vector { size: Tri, scalar: Scalar { kind: Bool, width: 1 } })
DEBUG Resolving [5] = Literal(AbstractFloat(1.055)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [6] = Literal(F32(1.055)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [7] = Splat { size: Tri, value: [6] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [8] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [9] = Literal(AbstractFloat(2.4)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, {AbstractFloat}
DEBUG consensus: {AbstractFloat}
DEBUG Resolving [10] = Literal(AbstractFloat(0.4166666666666667)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [11] = Literal(F32(0.41666666)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [12] = Splat { size: Tri, value: [11] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type vec3<f32>
DEBUG Remaining overloads: List {
rules: [
(vec3<f32>, vec3<f32>) -> vec3<f32>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 1 of type vec3<f32>
DEBUG Remaining overloads: List {
rules: [
(vec3<f32>, vec3<f32>) -> vec3<f32>,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Pow, List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type vec3<f32>: List {
rules: [
(vec3<f32>, vec3<f32>) -> vec3<f32>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type vec3<f32>: List {
rules: [
(vec3<f32>, vec3<f32>) -> vec3<f32>,
],
conclude: ArgumentType,
}
DEBUG Resolving [13] = Math { fun: Pow, arg: [0], arg1: Some([12]), arg2: None, arg3: None } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec3<f32>, vec3<f32>
DEBUG consensus: f32
DEBUG Resolving [14] = Binary { op: Multiply, left: [7], right: [13] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [15] = Literal(AbstractFloat(0.055)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [16] = Literal(F32(0.055)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [17] = Splat { size: Tri, value: [16] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec3<f32>, vec3<f32>
DEBUG consensus: f32
DEBUG Resolving [18] = Binary { op: Subtract, left: [14], right: [17] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [19] = Literal(AbstractFloat(12.92)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [20] = Literal(F32(12.92)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [21] = Splat { size: Tri, value: [20] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec3<f32>, vec3<f32>
DEBUG consensus: f32
DEBUG Resolving [22] = Binary { op: Multiply, left: [0], right: [21] } : Handle([1])
DEBUG Resolving [23] = Select { condition: [4], accept: [22], reject: [18] } : Handle([1])
DEBUG Resolving [0] = FunctionArgument(0) : Handle([2])
DEBUG Resolving [1] = Swizzle { size: Tri, vector: [0], pattern: [X, Y, Z, X] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [2] = CallResult([14]) : Handle([1])
DEBUG Resolving [3] = AccessIndex { base: [0], index: 3 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [4] = Compose { ty: [2], components: [[2], [3]] } : Handle([2])
DEBUG Resolving [0] = FunctionArgument(0) : Handle([2])
DEBUG Resolving [1] = Swizzle { size: Tri, vector: [0], pattern: [X, Y, Z, X] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [2] = CallResult([12]) : Handle([1])
DEBUG Resolving [3] = AccessIndex { base: [0], index: 3 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [4] = Compose { ty: [2], components: [[2], [3]] } : Handle([2])
DEBUG Resolving [0] = FunctionArgument(0) : Handle([11])
DEBUG Resolving [1] = AccessIndex { base: [0], index: 0 } : Handle([0])
DEBUG Resolving [2] = Literal(AbstractFloat(6.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [3] = Literal(F32(6.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [4] = Binary { op: Multiply, left: [1], right: [3] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [5] = AccessIndex { base: [0], index: 1 } : Handle([0])
DEBUG Resolving [6] = AccessIndex { base: [0], index: 2 } : Handle([0])
DEBUG Resolving [7] = AccessIndex { base: [0], index: 3 } : Handle([0])
DEBUG Resolving [8] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [9] = Literal(AbstractFloat(2.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [10] = Literal(F32(2.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [11] = Binary { op: Multiply, left: [10], right: [6] } : Handle([0])
DEBUG Resolving [12] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [13] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [14] = Binary { op: Subtract, left: [11], right: [13] } : Handle([0])
DEBUG Initial overloads: List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Abs, List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [15] = Math { fun: Abs, arg: [14], arg1: None, arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [16] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [17] = Binary { op: Subtract, left: [16], right: [15] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [18] = Binary { op: Multiply, left: [17], right: [5] } : Handle([0])
DEBUG Resolving [19] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [20] = Literal(AbstractFloat(2.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [21] = Literal(F32(2.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [22] = Binary { op: Modulo, left: [4], right: [21] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [23] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [24] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [25] = Binary { op: Subtract, left: [22], right: [24] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Initial overloads: List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Abs, List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [26] = Math { fun: Abs, arg: [25], arg1: None, arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [27] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [28] = Binary { op: Subtract, left: [27], right: [26] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [29] = Binary { op: Multiply, left: [18], right: [28] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [30] = Literal(AbstractFloat(2.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [31] = Literal(F32(2.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [32] = Binary { op: Divide, left: [18], right: [31] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [33] = Binary { op: Subtract, left: [6], right: [32] } : Handle([0])
DEBUG Resolving [34] = Splat { size: Tri, value: [33] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [35] = LocalVariable([0]) : Value(Pointer { base: [1], space: Function })
DEBUG Resolving [36] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [37] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [38] = Binary { op: GreaterEqual, left: [4], right: [37] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [39] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [40] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [41] = Binary { op: Less, left: [4], right: [40] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG wgsl automatic_conversion_consensus: bool, bool
DEBUG consensus: bool
DEBUG Resolving [42] = Binary { op: LogicalAnd, left: [38], right: [41] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [43] = AccessIndex { base: [35], index: 0 } : Value(ValuePointer { size: None, scalar: Scalar { kind: Float, width: 4 }, space: Function })
DEBUG Resolving [44] = Load { pointer: [43] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [45] = Binary { op: Add, left: [44], right: [18] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [46] = AccessIndex { base: [35], index: 1 } : Value(ValuePointer { size: None, scalar: Scalar { kind: Float, width: 4 }, space: Function })
DEBUG Resolving [47] = Load { pointer: [46] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [48] = Binary { op: Add, left: [47], right: [29] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [49] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [50] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [51] = Binary { op: GreaterEqual, left: [4], right: [50] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [52] = Literal(AbstractFloat(2.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [53] = Literal(F32(2.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [54] = Binary { op: Less, left: [4], right: [53] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG wgsl automatic_conversion_consensus: bool, bool
DEBUG consensus: bool
DEBUG Resolving [55] = Binary { op: LogicalAnd, left: [51], right: [54] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [56] = AccessIndex { base: [35], index: 0 } : Value(ValuePointer { size: None, scalar: Scalar { kind: Float, width: 4 }, space: Function })
DEBUG Resolving [57] = Load { pointer: [56] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [58] = Binary { op: Add, left: [57], right: [29] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [59] = AccessIndex { base: [35], index: 1 } : Value(ValuePointer { size: None, scalar: Scalar { kind: Float, width: 4 }, space: Function })
DEBUG Resolving [60] = Load { pointer: [59] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [61] = Binary { op: Add, left: [60], right: [18] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [62] = Literal(AbstractFloat(2.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [63] = Literal(F32(2.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [64] = Binary { op: GreaterEqual, left: [4], right: [63] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [65] = Literal(AbstractFloat(3.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [66] = Literal(F32(3.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [67] = Binary { op: Less, left: [4], right: [66] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG wgsl automatic_conversion_consensus: bool, bool
DEBUG consensus: bool
DEBUG Resolving [68] = Binary { op: LogicalAnd, left: [64], right: [67] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [69] = AccessIndex { base: [35], index: 1 } : Value(ValuePointer { size: None, scalar: Scalar { kind: Float, width: 4 }, space: Function })
DEBUG Resolving [70] = Load { pointer: [69] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [71] = Binary { op: Add, left: [70], right: [18] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [72] = AccessIndex { base: [35], index: 2 } : Value(ValuePointer { size: None, scalar: Scalar { kind: Float, width: 4 }, space: Function })
DEBUG Resolving [73] = Load { pointer: [72] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [74] = Binary { op: Add, left: [73], right: [29] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [75] = Literal(AbstractFloat(3.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [76] = Literal(F32(3.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [77] = Binary { op: GreaterEqual, left: [4], right: [76] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [78] = Literal(AbstractFloat(4.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [79] = Literal(F32(4.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [80] = Binary { op: Less, left: [4], right: [79] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG wgsl automatic_conversion_consensus: bool, bool
DEBUG consensus: bool
DEBUG Resolving [81] = Binary { op: LogicalAnd, left: [77], right: [80] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [82] = AccessIndex { base: [35], index: 1 } : Value(ValuePointer { size: None, scalar: Scalar { kind: Float, width: 4 }, space: Function })
DEBUG Resolving [83] = Load { pointer: [82] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [84] = Binary { op: Add, left: [83], right: [29] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [85] = AccessIndex { base: [35], index: 2 } : Value(ValuePointer { size: None, scalar: Scalar { kind: Float, width: 4 }, space: Function })
DEBUG Resolving [86] = Load { pointer: [85] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [87] = Binary { op: Add, left: [86], right: [18] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [88] = Literal(AbstractFloat(4.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [89] = Literal(F32(4.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [90] = Binary { op: GreaterEqual, left: [4], right: [89] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [91] = Literal(AbstractFloat(5.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [92] = Literal(F32(5.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [93] = Binary { op: Less, left: [4], right: [92] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG wgsl automatic_conversion_consensus: bool, bool
DEBUG consensus: bool
DEBUG Resolving [94] = Binary { op: LogicalAnd, left: [90], right: [93] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [95] = AccessIndex { base: [35], index: 0 } : Value(ValuePointer { size: None, scalar: Scalar { kind: Float, width: 4 }, space: Function })
DEBUG Resolving [96] = Load { pointer: [95] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [97] = Binary { op: Add, left: [96], right: [29] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [98] = AccessIndex { base: [35], index: 2 } : Value(ValuePointer { size: None, scalar: Scalar { kind: Float, width: 4 }, space: Function })
DEBUG Resolving [99] = Load { pointer: [98] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [100] = Binary { op: Add, left: [99], right: [18] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [101] = AccessIndex { base: [35], index: 0 } : Value(ValuePointer { size: None, scalar: Scalar { kind: Float, width: 4 }, space: Function })
DEBUG Resolving [102] = Load { pointer: [101] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [103] = Binary { op: Add, left: [102], right: [18] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [104] = AccessIndex { base: [35], index: 2 } : Value(ValuePointer { size: None, scalar: Scalar { kind: Float, width: 4 }, space: Function })
DEBUG Resolving [105] = Load { pointer: [104] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [106] = Binary { op: Add, left: [105], right: [29] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [107] = Load { pointer: [35] } : Handle([1])
DEBUG Resolving [108] = Compose { ty: [2], components: [[107], [7]] } : Handle([2])
DEBUG Resolving [0] = FunctionArgument(0) : Handle([2])
DEBUG Resolving [1] = Literal(AbstractFloat(0.4122214708)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [2] = AccessIndex { base: [0], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [3] = Literal(F32(0.41222146)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [4] = Binary { op: Multiply, left: [3], right: [2] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [5] = Literal(AbstractFloat(0.5363325363)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [6] = AccessIndex { base: [0], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [7] = Literal(F32(0.53633255)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [8] = Binary { op: Multiply, left: [7], right: [6] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [9] = Binary { op: Add, left: [4], right: [8] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [10] = Literal(AbstractFloat(0.0514459929)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [11] = AccessIndex { base: [0], index: 2 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [12] = Literal(F32(0.051445995)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [13] = Binary { op: Multiply, left: [12], right: [11] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [14] = Binary { op: Add, left: [9], right: [13] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [15] = Literal(AbstractFloat(0.2119034982)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [16] = AccessIndex { base: [0], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [17] = Literal(F32(0.2119035)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [18] = Binary { op: Multiply, left: [17], right: [16] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [19] = Literal(AbstractFloat(0.6806995451)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [20] = AccessIndex { base: [0], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [21] = Literal(F32(0.6806995)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [22] = Binary { op: Multiply, left: [21], right: [20] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [23] = Binary { op: Add, left: [18], right: [22] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [24] = Literal(AbstractFloat(0.1073969566)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [25] = AccessIndex { base: [0], index: 2 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [26] = Literal(F32(0.10739696)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [27] = Binary { op: Multiply, left: [26], right: [25] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [28] = Binary { op: Add, left: [23], right: [27] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [29] = Literal(AbstractFloat(0.0883024619)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [30] = AccessIndex { base: [0], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [31] = Literal(F32(0.08830246)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [32] = Binary { op: Multiply, left: [31], right: [30] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [33] = Literal(AbstractFloat(0.2817188376)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [34] = AccessIndex { base: [0], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [35] = Literal(F32(0.28171885)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [36] = Binary { op: Multiply, left: [35], right: [34] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [37] = Binary { op: Add, left: [32], right: [36] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [38] = Literal(AbstractFloat(0.6299787005)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [39] = AccessIndex { base: [0], index: 2 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [40] = Literal(F32(0.6299787)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [41] = Binary { op: Multiply, left: [40], right: [39] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [42] = Binary { op: Add, left: [37], right: [41] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [43] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [44] = Literal(AbstractFloat(3.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, {AbstractFloat}
DEBUG consensus: {AbstractFloat}
DEBUG Resolving [45] = Literal(AbstractFloat(0.3333333333333333)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 1 of type {AbstractFloat}
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [46] = Literal(F32(0.33333334)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG initial overloads for Pow, List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [47] = Math { fun: Pow, arg: [14], arg1: Some([46]), arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [48] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [49] = Literal(AbstractFloat(3.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, {AbstractFloat}
DEBUG consensus: {AbstractFloat}
DEBUG Resolving [50] = Literal(AbstractFloat(0.3333333333333333)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 1 of type {AbstractFloat}
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [51] = Literal(F32(0.33333334)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG initial overloads for Pow, List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [52] = Math { fun: Pow, arg: [28], arg1: Some([51]), arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [53] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [54] = Literal(AbstractFloat(3.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, {AbstractFloat}
DEBUG consensus: {AbstractFloat}
DEBUG Resolving [55] = Literal(AbstractFloat(0.3333333333333333)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 1 of type {AbstractFloat}
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [56] = Literal(F32(0.33333334)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG initial overloads for Pow, List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [57] = Math { fun: Pow, arg: [42], arg1: Some([56]), arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [58] = Literal(AbstractFloat(0.2104542553)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [59] = Literal(F32(0.21045426)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [60] = Binary { op: Multiply, left: [59], right: [47] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [61] = Literal(AbstractFloat(0.793617785)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [62] = Literal(F32(0.7936178)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [63] = Binary { op: Multiply, left: [62], right: [52] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [64] = Binary { op: Add, left: [60], right: [63] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [65] = Literal(AbstractFloat(0.0040720468)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [66] = Literal(F32(0.004072047)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [67] = Binary { op: Multiply, left: [66], right: [57] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [68] = Binary { op: Subtract, left: [64], right: [67] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [69] = Literal(AbstractFloat(1.9779984951)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [70] = Literal(F32(1.9779985)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [71] = Binary { op: Multiply, left: [70], right: [47] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [72] = Literal(AbstractFloat(2.428592205)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [73] = Literal(F32(2.4285922)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [74] = Binary { op: Multiply, left: [73], right: [52] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [75] = Binary { op: Subtract, left: [71], right: [74] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [76] = Literal(AbstractFloat(0.4505937099)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [77] = Literal(F32(0.4505937)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [78] = Binary { op: Multiply, left: [77], right: [57] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [79] = Binary { op: Add, left: [75], right: [78] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [80] = Literal(AbstractFloat(0.0259040371)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [81] = Literal(F32(0.025904037)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [82] = Binary { op: Multiply, left: [81], right: [47] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [83] = Literal(AbstractFloat(0.7827717662)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [84] = Literal(F32(0.78277177)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [85] = Binary { op: Multiply, left: [84], right: [52] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [86] = Binary { op: Add, left: [82], right: [85] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [87] = Literal(AbstractFloat(0.808675766)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [88] = Literal(F32(0.80867577)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [89] = Binary { op: Multiply, left: [88], right: [57] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [90] = Binary { op: Subtract, left: [86], right: [89] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [91] = AccessIndex { base: [0], index: 3 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [92] = Compose { ty: [2], components: [[68], [79], [90], [91]] } : Handle([2])
DEBUG Resolving [0] = FunctionArgument(0) : Handle([2])
DEBUG Resolving [1] = AccessIndex { base: [0], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [2] = Literal(AbstractFloat(0.3963377774)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [3] = AccessIndex { base: [0], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [4] = Literal(F32(0.39633778)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [5] = Binary { op: Multiply, left: [4], right: [3] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [6] = Binary { op: Add, left: [1], right: [5] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [7] = Literal(AbstractFloat(0.2158037573)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [8] = AccessIndex { base: [0], index: 2 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [9] = Literal(F32(0.21580376)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [10] = Binary { op: Multiply, left: [9], right: [8] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [11] = Binary { op: Add, left: [6], right: [10] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [12] = AccessIndex { base: [0], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [13] = Literal(AbstractFloat(0.1055613458)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [14] = AccessIndex { base: [0], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [15] = Literal(F32(0.105561346)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [16] = Binary { op: Multiply, left: [15], right: [14] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [17] = Binary { op: Subtract, left: [12], right: [16] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [18] = Literal(AbstractFloat(0.0638541728)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [19] = AccessIndex { base: [0], index: 2 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [20] = Literal(F32(0.06385417)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [21] = Binary { op: Multiply, left: [20], right: [19] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [22] = Binary { op: Subtract, left: [17], right: [21] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [23] = AccessIndex { base: [0], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [24] = Literal(AbstractFloat(0.0894841775)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [25] = AccessIndex { base: [0], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [26] = Literal(F32(0.08948418)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [27] = Binary { op: Multiply, left: [26], right: [25] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [28] = Binary { op: Subtract, left: [23], right: [27] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [29] = Literal(AbstractFloat(1.291485548)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [30] = AccessIndex { base: [0], index: 2 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [31] = Literal(F32(1.2914855)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [32] = Binary { op: Multiply, left: [31], right: [30] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [33] = Binary { op: Subtract, left: [28], right: [32] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [34] = Binary { op: Multiply, left: [11], right: [11] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [35] = Binary { op: Multiply, left: [34], right: [11] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [36] = Binary { op: Multiply, left: [22], right: [22] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [37] = Binary { op: Multiply, left: [36], right: [22] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [38] = Binary { op: Multiply, left: [33], right: [33] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [39] = Binary { op: Multiply, left: [38], right: [33] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [40] = Literal(AbstractFloat(4.0767416621)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [41] = Literal(F32(4.0767417)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [42] = Binary { op: Multiply, left: [41], right: [35] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [43] = Literal(AbstractFloat(3.3077115913)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [44] = Literal(F32(3.3077116)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [45] = Binary { op: Multiply, left: [44], right: [37] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [46] = Binary { op: Subtract, left: [42], right: [45] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [47] = Literal(AbstractFloat(0.2309699292)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [48] = Literal(F32(0.23096994)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [49] = Binary { op: Multiply, left: [48], right: [39] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [50] = Binary { op: Add, left: [46], right: [49] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [51] = Literal(AbstractFloat(1.2684380046)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [52] = Literal(AbstractFloat(-1.2684380046)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [53] = Literal(F32(-1.268438)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [54] = Binary { op: Multiply, left: [53], right: [35] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [55] = Literal(AbstractFloat(2.6097574011)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [56] = Literal(F32(2.6097574)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [57] = Binary { op: Multiply, left: [56], right: [37] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [58] = Binary { op: Add, left: [54], right: [57] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [59] = Literal(AbstractFloat(0.3413193965)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [60] = Literal(F32(0.34131938)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [61] = Binary { op: Multiply, left: [60], right: [39] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [62] = Binary { op: Subtract, left: [58], right: [61] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [63] = Literal(AbstractFloat(0.0041960863)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [64] = Literal(AbstractFloat(-0.0041960863)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [65] = Literal(F32(-0.0041960864)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [66] = Binary { op: Multiply, left: [65], right: [35] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [67] = Literal(AbstractFloat(0.7034186147)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [68] = Literal(F32(0.7034186)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [69] = Binary { op: Multiply, left: [68], right: [37] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [70] = Binary { op: Subtract, left: [66], right: [69] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [71] = Literal(AbstractFloat(1.707614701)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [72] = Literal(F32(1.7076147)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [73] = Binary { op: Multiply, left: [72], right: [39] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [74] = Binary { op: Add, left: [70], right: [73] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [75] = AccessIndex { base: [0], index: 3 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [76] = Compose { ty: [2], components: [[50], [62], [74], [75]] } : Handle([2])
DEBUG Resolving [0] = FunctionArgument(0) : Handle([2])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([2])
DEBUG Resolving [2] = AccessIndex { base: [1], index: 3 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [3] = AccessIndex { base: [0], index: 3 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [4] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [5] = AccessIndex { base: [1], index: 3 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [6] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [7] = Binary { op: Subtract, left: [6], right: [5] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [8] = Binary { op: Multiply, left: [3], right: [7] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [9] = Binary { op: Add, left: [2], right: [8] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [10] = Swizzle { size: Tri, vector: [1], pattern: [X, Y, Z, X] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [11] = AccessIndex { base: [1], index: 3 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: vec3<f32>, f32
DEBUG consensus: f32
DEBUG Resolving [12] = Binary { op: Multiply, left: [10], right: [11] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [13] = Swizzle { size: Tri, vector: [0], pattern: [X, Y, Z, X] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [14] = AccessIndex { base: [0], index: 3 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: vec3<f32>, f32
DEBUG consensus: f32
DEBUG Resolving [15] = Binary { op: Multiply, left: [13], right: [14] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [16] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [17] = AccessIndex { base: [1], index: 3 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [18] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [19] = Binary { op: Subtract, left: [18], right: [17] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: vec3<f32>, f32
DEBUG consensus: f32
DEBUG Resolving [20] = Binary { op: Multiply, left: [15], right: [19] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec3<f32>, vec3<f32>
DEBUG consensus: f32
DEBUG Resolving [21] = Binary { op: Add, left: [12], right: [20] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [22] = Splat { size: Tri, value: [9] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec3<f32>, vec3<f32>
DEBUG consensus: f32
DEBUG Resolving [23] = Binary { op: Divide, left: [21], right: [22] } : Value(Vector { size: Tri, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [24] = Compose { ty: [2], components: [[23], [9]] } : Handle([2])
DEBUG Resolving [0] = FunctionArgument(0) : Handle([0])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [2] = Binary { op: Multiply, left: [0], right: [0] } : Handle([0])
DEBUG Resolving [3] = Unary { op: Negate, expr: [2] } : Handle([0])
DEBUG Resolving [4] = Literal(AbstractFloat(2.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [5] = Literal(F32(2.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [6] = Binary { op: Multiply, left: [5], right: [1] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [7] = Binary { op: Multiply, left: [6], right: [1] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [8] = Binary { op: Divide, left: [3], right: [7] } : Handle([0])
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Exp, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [9] = Math { fun: Exp, arg: [8], arg1: None, arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [10] = Literal(AbstractFloat(2.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [11] = Constant([0]) : Handle([0])
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [12] = Literal(F32(2.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [13] = Literal(F32(3.1415925)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [14] = Literal(F32(6.283185)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [15] = Literal(F32(2.5066283)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [16] = Binary { op: Multiply, left: [15], right: [1] } : Handle([0])
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [17] = Binary { op: Divide, left: [9], right: [16] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [0] = FunctionArgument(0) : Handle([3])
DEBUG Initial overloads: List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type vec2<f32>
DEBUG Remaining overloads: List {
rules: [
(vec2<f32>) -> vec2<f32>,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Sign, List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type vec2<f32>: List {
rules: [
(vec2<f32>) -> vec2<f32>,
],
conclude: ArgumentType,
}
DEBUG Resolving [1] = Math { fun: Sign, arg: [0], arg1: None, arg2: None, arg3: None } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Initial overloads: List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type vec2<f32>
DEBUG Remaining overloads: List {
rules: [
(vec2<f32>) -> vec2<f32>,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Abs, List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type vec2<f32>: List {
rules: [
(vec2<f32>) -> vec2<f32>,
],
conclude: ArgumentType,
}
DEBUG Resolving [2] = Math { fun: Abs, arg: [0], arg1: None, arg2: None, arg3: None } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [3] = Literal(AbstractFloat(1.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [4] = Literal(AbstractFloat(0.278393)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [5] = Literal(AbstractFloat(0.230389)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [6] = Literal(AbstractFloat(0.000972)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [7] = Literal(AbstractFloat(0.078108)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [8] = Literal(F32(0.078108)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [9] = Binary { op: Multiply, left: [8], right: [2] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [10] = Splat { size: Bi, value: [6] } : Value(Vector { size: Bi, scalar: Scalar { kind: AbstractFloat, width: 8 } })
DEBUG wgsl automatic_conversion_consensus: vec2<{AbstractFloat}>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [11] = Literal(F32(0.000972)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [12] = Splat { size: Bi, value: [11] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [13] = Binary { op: Add, left: [12], right: [9] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [14] = Binary { op: Multiply, left: [13], right: [2] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [15] = Splat { size: Bi, value: [5] } : Value(Vector { size: Bi, scalar: Scalar { kind: AbstractFloat, width: 8 } })
DEBUG wgsl automatic_conversion_consensus: vec2<{AbstractFloat}>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [16] = Literal(F32(0.230389)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [17] = Splat { size: Bi, value: [16] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [18] = Binary { op: Add, left: [17], right: [14] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [19] = Binary { op: Multiply, left: [18], right: [2] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [20] = Splat { size: Bi, value: [4] } : Value(Vector { size: Bi, scalar: Scalar { kind: AbstractFloat, width: 8 } })
DEBUG wgsl automatic_conversion_consensus: vec2<{AbstractFloat}>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [21] = Literal(F32(0.278393)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [22] = Splat { size: Bi, value: [21] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [23] = Binary { op: Add, left: [22], right: [19] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [24] = Binary { op: Multiply, left: [23], right: [2] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [25] = Splat { size: Bi, value: [3] } : Value(Vector { size: Bi, scalar: Scalar { kind: AbstractFloat, width: 8 } })
DEBUG wgsl automatic_conversion_consensus: vec2<{AbstractFloat}>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [26] = Literal(F32(1.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [27] = Splat { size: Bi, value: [26] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [28] = Binary { op: Add, left: [27], right: [24] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [29] = Binary { op: Multiply, left: [28], right: [28] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [30] = Binary { op: Multiply, left: [29], right: [29] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [31] = Binary { op: Divide, left: [1], right: [30] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [32] = Binary { op: Subtract, left: [1], right: [31] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [0] = FunctionArgument(0) : Handle([0])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([0])
DEBUG Resolving [2] = FunctionArgument(2) : Handle([0])
DEBUG Resolving [3] = FunctionArgument(3) : Handle([0])
DEBUG Resolving [4] = FunctionArgument(4) : Handle([3])
DEBUG Resolving [5] = AccessIndex { base: [4], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Initial overloads: List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [6] = Binary { op: Subtract, left: [5], right: [3] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG initial overloads for Abs, List {
rules: [
({AbstractInt}) -> {AbstractInt},
({AbstractFloat}) -> {AbstractFloat},
(i32) -> i32,
(i64) -> i64,
(u32) -> u32,
(u64) -> u64,
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>) -> vec2<i32>,
(vec2<i64>) -> vec2<i64>,
(vec2<u32>) -> vec2<u32>,
(vec2<u64>) -> vec2<u64>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>) -> vec3<i32>,
(vec3<i64>) -> vec3<i64>,
(vec3<u32>) -> vec3<u32>,
(vec3<u64>) -> vec3<u64>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>) -> vec4<i32>,
(vec4<i64>) -> vec4<i64>,
(vec4<u32>) -> vec4<u32>,
(vec4<u64>) -> vec4<u64>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [7] = Math { fun: Abs, arg: [1], arg1: None, arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [8] = Binary { op: Subtract, left: [6], right: [7] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [9] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Initial overloads: List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 1 of type {AbstractFloat}
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [10] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG initial overloads for Min, List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [11] = Math { fun: Min, arg: [8], arg1: Some([10]), arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [12] = AccessIndex { base: [4], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [13] = Binary { op: Subtract, left: [12], right: [3] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [14] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [15] = Binary { op: Multiply, left: [3], right: [3] } : Handle([0])
DEBUG Resolving [16] = Binary { op: Multiply, left: [11], right: [11] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [17] = Binary { op: Subtract, left: [15], right: [16] } : Handle([0])
DEBUG Initial overloads: List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type {AbstractFloat}
DEBUG Remaining overloads: List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 1 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [18] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG initial overloads for Max, List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [19] = Math { fun: Max, arg: [18], arg1: Some([17]), arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Sqrt, List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [20] = Math { fun: Sqrt, arg: [19], arg1: None, arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [21] = Binary { op: Add, left: [13], right: [20] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [22] = Literal(AbstractFloat(0.5)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [23] = Literal(AbstractFloat(0.5)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [24] = Unary { op: Negate, expr: [21] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [25] = Compose { ty: [3], components: [[24], [21]] } : Handle([3])
DEBUG Resolving [26] = Splat { size: Bi, value: [0] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [27] = Binary { op: Add, left: [26], right: [25] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [28] = Literal(AbstractFloat(0.5)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Initial overloads: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<f32>) -> vec2<f32>,
(vec2<f16>) -> vec2<f16>,
(vec2<f64>) -> vec2<f64>,
(vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<f32>) -> vec3<f32>,
(vec3<f16>) -> vec3<f16>,
(vec3<f64>) -> vec3<f64>,
(vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<f32>) -> vec4<f32>,
(vec4<f16>) -> vec4<f16>,
(vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type {AbstractFloat}
DEBUG Remaining overloads: List {
rules: [
({AbstractFloat}) -> {AbstractFloat},
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
],
conclude: ArgumentType,
}
DEBUG Resolving [29] = Literal(AbstractFloat(0.7071067811865476)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, f32
DEBUG consensus: f32
DEBUG Resolving [30] = Literal(F32(0.70710677)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [31] = Binary { op: Divide, left: [30], right: [2] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: vec2<f32>, f32
DEBUG consensus: f32
DEBUG Resolving [32] = Binary { op: Multiply, left: [27], right: [31] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [33] = CallResult([22]) : Handle([3])
DEBUG wgsl automatic_conversion_consensus: {AbstractFloat}, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [34] = Literal(F32(0.5)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [35] = Binary { op: Multiply, left: [34], right: [33] } : Handle([3])
DEBUG Resolving [36] = Splat { size: Bi, value: [22] } : Value(Vector { size: Bi, scalar: Scalar { kind: AbstractFloat, width: 8 } })
DEBUG wgsl automatic_conversion_consensus: vec2<{AbstractFloat}>, vec2<f32>
DEBUG consensus: f32
DEBUG Resolving [37] = Literal(F32(0.5)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [38] = Splat { size: Bi, value: [37] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [39] = Binary { op: Add, left: [38], right: [35] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Resolving [40] = AccessIndex { base: [39], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [41] = AccessIndex { base: [39], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG wgsl automatic_conversion_consensus: f32, f32
DEBUG consensus: f32
DEBUG Resolving [42] = Binary { op: Subtract, left: [40], right: [41] } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [0] = FunctionArgument(0) : Handle([3])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([9])
DEBUG Resolving [2] = AccessIndex { base: [0], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [3] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [4] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [5] = Binary { op: Less, left: [2], right: [4] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [6] = AccessIndex { base: [0], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [7] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [8] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [9] = Binary { op: Less, left: [6], right: [8] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [10] = AccessIndex { base: [1], index: 0 } : Handle([0])
DEBUG Resolving [11] = AccessIndex { base: [1], index: 3 } : Handle([0])
DEBUG Resolving [12] = AccessIndex { base: [0], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [13] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [14] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [15] = Binary { op: Less, left: [12], right: [14] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [16] = AccessIndex { base: [1], index: 1 } : Handle([0])
DEBUG Resolving [17] = AccessIndex { base: [1], index: 2 } : Handle([0])
DEBUG Resolving [0] = FunctionArgument(0) : Handle([3])
DEBUG Resolving [1] = FunctionArgument(1) : Handle([0])
DEBUG Resolving [2] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG wgsl automatic_conversion_consensus: f32, {AbstractFloat}
DEBUG consensus: f32
DEBUG Resolving [3] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [4] = Binary { op: Equal, left: [1], right: [3] } : Value(Scalar(Scalar { kind: Bool, width: 1 }))
DEBUG Resolving [5] = AccessIndex { base: [0], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [6] = AccessIndex { base: [0], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Initial overloads: List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 1 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Max, List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [7] = Math { fun: Max, arg: [5], arg1: Some([6]), arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [8] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [9] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [10] = Splat { size: Bi, value: [9] } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Initial overloads: List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type vec2<f32>
DEBUG Remaining overloads: List {
rules: [
(vec2<f32>, vec2<f32>) -> vec2<f32>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 1 of type vec2<f32>
DEBUG Remaining overloads: List {
rules: [
(vec2<f32>, vec2<f32>) -> vec2<f32>,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Max, List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type vec2<f32>: List {
rules: [
(vec2<f32>, vec2<f32>) -> vec2<f32>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type vec2<f32>: List {
rules: [
(vec2<f32>, vec2<f32>) -> vec2<f32>,
],
conclude: ArgumentType,
}
DEBUG Resolving [11] = Math { fun: Max, arg: [10], arg1: Some([0]), arg2: None, arg3: None } : Value(Vector { size: Bi, scalar: Scalar { kind: Float, width: 4 } })
DEBUG Initial overloads: List {
rules: [
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<f32>) -> f32,
(vec2<f16>) -> f16,
(vec2<f64>) -> f64,
(vec3<f32>) -> f32,
(vec3<f16>) -> f16,
(vec3<f64>) -> f64,
(vec4<f32>) -> f32,
(vec4<f16>) -> f16,
(vec4<f64>) -> f64,
],
conclude: Scalar,
}
DEBUG Supplying argument 0 of type vec2<f32>
DEBUG Remaining overloads: List {
rules: [
(vec2<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG initial overloads for Length, List {
rules: [
(f32) -> f32,
(f16) -> f16,
(f64) -> f64,
(vec2<f32>) -> f32,
(vec2<f16>) -> f16,
(vec2<f64>) -> f64,
(vec3<f32>) -> f32,
(vec3<f16>) -> f16,
(vec3<f64>) -> f64,
(vec4<f32>) -> f32,
(vec4<f16>) -> f16,
(vec4<f64>) -> f64,
],
conclude: Scalar,
}
DEBUG overloads after arg 0 of type vec2<f32>: List {
rules: [
(vec2<f32>) -> f32,
],
conclude: Scalar,
}
DEBUG Resolving [12] = Math { fun: Length, arg: [11], arg1: None, arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [13] = Literal(AbstractFloat(0.0)) : Value(Scalar(Scalar { kind: AbstractFloat, width: 8 }))
DEBUG Resolving [14] = AccessIndex { base: [0], index: 0 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Resolving [15] = AccessIndex { base: [0], index: 1 } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Initial overloads: List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 1 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG initial overloads for Max, List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 0 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG overloads after arg 1 of type f32: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [16] = Math { fun: Max, arg: [14], arg1: Some([15]), arg2: None, arg3: None } : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG Initial overloads: List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>) -> vec2<{AbstractInt}>,
(vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}>,
(vec2<i32>, vec2<i32>) -> vec2<i32>,
(vec2<i64>, vec2<i64>) -> vec2<i64>,
(vec2<u32>, vec2<u32>) -> vec2<u32>,
(vec2<u64>, vec2<u64>) -> vec2<u64>,
(vec2<f32>, vec2<f32>) -> vec2<f32>,
(vec2<f16>, vec2<f16>) -> vec2<f16>,
(vec2<f64>, vec2<f64>) -> vec2<f64>,
(vec3<{AbstractInt}>, vec3<{AbstractInt}>) -> vec3<{AbstractInt}>,
(vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}>,
(vec3<i32>, vec3<i32>) -> vec3<i32>,
(vec3<i64>, vec3<i64>) -> vec3<i64>,
(vec3<u32>, vec3<u32>) -> vec3<u32>,
(vec3<u64>, vec3<u64>) -> vec3<u64>,
(vec3<f32>, vec3<f32>) -> vec3<f32>,
(vec3<f16>, vec3<f16>) -> vec3<f16>,
(vec3<f64>, vec3<f64>) -> vec3<f64>,
(vec4<{AbstractInt}>, vec4<{AbstractInt}>) -> vec4<{AbstractInt}>,
(vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}>,
(vec4<i32>, vec4<i32>) -> vec4<i32>,
(vec4<i64>, vec4<i64>) -> vec4<i64>,
(vec4<u32>, vec4<u32>) -> vec4<u32>,
(vec4<u64>, vec4<u64>) -> vec4<u64>,
(vec4<f32>, vec4<f32>) -> vec4<f32>,
(vec4<f16>, vec4<f16>) -> vec4<f16>,
(vec4<f64>, vec4<f64>) -> vec4<f64>,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 0 of type {AbstractFloat}
DEBUG Remaining overloads: List {
rules: [
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
],
conclude: ArgumentType,
}
DEBUG Supplying argument 1 of type f32
DEBUG Remaining overloads: List {
rules: [
(f32, f32) -> f32,
],
conclude: ArgumentType,
}
DEBUG Resolving [17] = Literal(F32(0.0)) : Value(Scalar(Scalar { kind: Float, width: 4 }))
DEBUG initial overloads for Min, List {
rules: [
({AbstractInt}, {AbstractInt}) -> {AbstractInt},
({AbstractFloat}, {AbstractFloat}) -> {AbstractFloat},
(i32, i32) -> i32,
(i64, i64) -> i64,
(u32, u32) -> u32,
(u64, u64) -> u64,
(f32, f32) -> f32,
(f16, f16) -> f16,
(f64, f64) -> f64,
(vec2<{AbstractInt}>, vec2<{AbstractInt}>
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment