idevice_pair doesn't pair iOS 26.2 and Linux

[mgr34]

I cannot get my device to pair.

Some details
os: linux
kernal: 7.0.7-arch2-1
usbmuxd: 1.1.1
iOS: 26.2
Model: Iphone 16

What happens:

1. sudo usbmuxd -f -v
2. plug in my phone, hit trust, enter passcode
3. idevice pair it shows up and I hit Pairing Type RPPairing, then generate. It stats stuck on Loading indefinitely.

Am I doing something wrong? Ultimately, I just want to take a backup and export my messages (imessage-exporter) before I delete them off the phone. I can get the pair to work on my Macbook air, but don't have enough space to backup on there.

I'll attach some logs here in other messages.

[mgr34]

logs: (idevice_pair and then usbmuxd)

14:25:28 [DEBUG] naga::valid::expression                   : 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,
} 
14:25:28 [DEBUG] naga::valid::expression                   : overloads after arg 0: List {
    rules: [
        (vec2<i32>, vec2<i32>, vec2<i32>) -> vec2<i32>,
    ],
    conclude: ArgumentType,
} 
14:25:28 [DEBUG] naga::valid::expression                   : overloads after arg 1: List {
    rules: [
        (vec2<i32>, vec2<i32>, vec2<i32>) -> vec2<i32>,
    ],
    conclude: ArgumentType,
} 
14:25:28 [DEBUG] naga::valid::expression                   : overloads after arg 2: List {
    rules: [
        (vec2<i32>, vec2<i32>, vec2<i32>) -> vec2<i32>,
    ],
    conclude: ArgumentType,
} 
14:25:28 [DEBUG] naga::valid::expression                   : 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,
} 
14:25:28 [DEBUG] naga::valid::expression                   : overloads after arg 0: List {
    rules: [
        (vec2<i32>, vec2<i32>, vec2<i32>) -> vec2<i32>,
    ],
    conclude: ArgumentType,
} 
14:25:28 [DEBUG] naga::valid::expression                   : overloads after arg 1: List {
    rules: [
        (vec2<i32>, vec2<i32>, vec2<i32>) -> vec2<i32>,
    ],
    conclude: ArgumentType,
} 
14:25:28 [DEBUG] naga::valid::expression                   : overloads after arg 2: List {
    rules: [
        (vec2<i32>, vec2<i32>, vec2<i32>) -> vec2<i32>,
    ],
    conclude: ArgumentType,
} 
14:25:28 [DEBUG] naga::valid::expression                   : 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>,
] 
14:25:28 [DEBUG] naga::proc::overloads::list               : arg 0 of type vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat} 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat} 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, {AbstractFloat}) -> vec2<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, {AbstractFloat}) -> vec3<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, {AbstractFloat}) -> vec4<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f32, f32, f32) -> f32 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f32, f32, f32) -> f32 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f32>, vec2<f32>, f32) -> vec2<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f32>, vec3<f32>, f32) -> vec3<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f16, f16, f16) -> f16 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f16, f16, f16) -> f16 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f16>, vec2<f16>, f16) -> vec2<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f16>, vec3<f16>, f16) -> vec3<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f16>, vec4<f16>, f16) -> vec4<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f64, f64, f64) -> f64 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f64, f64, f64) -> f64 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f64>, vec2<f64>, f64) -> vec2<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f64>, vec3<f64>, f64) -> vec3<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f64>, vec4<f64>, f64) -> vec4<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::valid::expression                   : overloads after arg 0: [
    (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
    (vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
] 
14:25:28 [DEBUG] naga::proc::overloads::list               : arg 1 of type vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::valid::expression                   : overloads after arg 1: [
    (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
    (vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
] 
14:25:28 [DEBUG] naga::proc::overloads::list               : arg 2 of type f32 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::valid::expression                   : overloads after arg 2: [
    (vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
] 
14:25:28 [DEBUG] naga::valid::expression                   : 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>,
] 
14:25:28 [DEBUG] naga::proc::overloads::list               : arg 0 of type vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat} 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat} 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, {AbstractFloat}) -> vec2<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, {AbstractFloat}) -> vec3<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, {AbstractFloat}) -> vec4<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f32, f32, f32) -> f32 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f32, f32, f32) -> f32 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f32>, vec2<f32>, f32) -> vec2<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f32>, vec3<f32>, f32) -> vec3<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f16, f16, f16) -> f16 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f16, f16, f16) -> f16 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f16>, vec2<f16>, f16) -> vec2<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f16>, vec3<f16>, f16) -> vec3<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f16>, vec4<f16>, f16) -> vec4<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f64, f64, f64) -> f64 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f64, f64, f64) -> f64 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f64>, vec2<f64>, f64) -> vec2<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f64>, vec3<f64>, f64) -> vec3<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f64>, vec4<f64>, f64) -> vec4<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::valid::expression                   : overloads after arg 0: [
    (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
    (vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
] 
14:25:28 [DEBUG] naga::proc::overloads::list               : arg 1 of type vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::valid::expression                   : overloads after arg 1: [
    (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
    (vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
] 
14:25:28 [DEBUG] naga::proc::overloads::list               : arg 2 of type f32 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::valid::expression                   : overloads after arg 2: [
    (vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
] 
14:25:28 [DEBUG] naga::valid::expression                   : 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>,
] 
14:25:28 [DEBUG] naga::proc::overloads::list               : arg 0 of type vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat} 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat} 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, {AbstractFloat}) -> vec2<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, {AbstractFloat}) -> vec3<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, {AbstractFloat}) -> vec4<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f32, f32, f32) -> f32 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f32, f32, f32) -> f32 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f32>, vec2<f32>, f32) -> vec2<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f32>, vec3<f32>, f32) -> vec3<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f16, f16, f16) -> f16 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f16, f16, f16) -> f16 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f16>, vec2<f16>, f16) -> vec2<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f16>, vec3<f16>, f16) -> vec3<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f16>, vec4<f16>, f16) -> vec4<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f64, f64, f64) -> f64 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f64, f64, f64) -> f64 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f64>, vec2<f64>, f64) -> vec2<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f64>, vec3<f64>, f64) -> vec3<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f64>, vec4<f64>, f64) -> vec4<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::valid::expression                   : overloads after arg 0: [
    (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
    (vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
] 
14:25:28 [DEBUG] naga::proc::overloads::list               : arg 1 of type vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::valid::expression                   : overloads after arg 1: [
    (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
    (vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
] 
14:25:28 [DEBUG] naga::proc::overloads::list               : arg 2 of type f32 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::valid::expression                   : overloads after arg 2: [
    (vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
] 
14:25:28 [DEBUG] naga::valid::function                     : var LocalVariable { name: Some("out"), ty: [3], init: None } 
14:25:28 [DEBUG] naga::valid::function                     : var LocalVariable { name: Some("out_color_gamma"), ty: [2], init: None } 
14:25:28 [DEBUG] naga::valid::function                     : var LocalVariable { name: Some("out_color_gamma"), ty: [2], init: None } 
14:25:28 [DEBUG] naga::valid::interface                    : var GlobalVariable { name: Some("r_locals"), space: Uniform, binding: Some(ResourceBinding { group: 0, binding: 0 }), ty: [4], init: None } 
14:25:28 [DEBUG] naga::valid::function                     : var LocalVariable { name: Some("out"), ty: [2], init: None } 
14:25:28 [DEBUG] naga::valid::interface                    : var GlobalVariable { name: Some("r_locals"), space: Uniform, binding: Some(ResourceBinding { group: 0, binding: 0 }), ty: [5], init: None } 
14:25:28 [DEBUG] naga::valid::interface                    : var GlobalVariable { name: Some("r_tex_color"), space: Handle, binding: Some(ResourceBinding { group: 1, binding: 0 }), ty: [7], init: None } 
14:25:28 [DEBUG] naga::valid::interface                    : var GlobalVariable { name: Some("r_tex_sampler"), space: Handle, binding: Some(ResourceBinding { group: 1, binding: 1 }), ty: [8], init: None } 
14:25:28 [DEBUG] naga::proc::typifier                      : initial overloads for Fract, 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,
} 
14:25:28 [DEBUG] naga::proc::typifier                      : overloads after arg 0 of type f32: List {
    rules: [
        (f32) -> f32,
    ],
    conclude: ArgumentType,
} 
14:25:28 [DEBUG] naga::proc::typifier                      : initial overloads for Fract, 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,
} 
14:25:28 [DEBUG] naga::proc::typifier                      : overloads after arg 0 of type f32: List {
    rules: [
        (f32) -> f32,
    ],
    conclude: ArgumentType,
} 
14:25:28 [DEBUG] naga::valid::expression                   : initial overloads for Fract: 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,
} 
14:25:28 [DEBUG] naga::valid::expression                   : overloads after arg 0: List {
    rules: [
        (f32) -> f32,
    ],
    conclude: ArgumentType,
} 
14:25:28 [DEBUG] naga::valid::expression                   : initial overloads for Fract: 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,
} 
14:25:28 [DEBUG] naga::valid::expression                   : overloads after arg 0: List {
    rules: [
        (f32) -> f32,
    ],
    conclude: ArgumentType,
} 
14:25:28 [DEBUG] naga::valid::function                     : var LocalVariable { name: Some("noise"), ty: [0], init: None } 
14:25:28 [DEBUG] naga::proc::typifier                      : initial overloads for Fract, 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,
} 
14:25:28 [DEBUG] naga::proc::typifier                      : overloads after arg 0 of type vec2<f32>: List {
    rules: [
        (vec2<f32>) -> vec2<f32>,
    ],
    conclude: ArgumentType,
} 
14:25:28 [DEBUG] naga::proc::typifier                      : 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,
} 
14:25:28 [DEBUG] naga::proc::typifier                      : overloads after arg 0 of type vec2<f32>: List {
    rules: [
        (vec2<f32>) -> vec2<f32>,
    ],
    conclude: ArgumentType,
} 
14:25:28 [DEBUG] naga::proc::typifier                      : 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,
} 
14:25:28 [DEBUG] naga::proc::typifier                      : overloads after arg 0 of type vec2<i32>: List {
    rules: [
        (vec2<i32>, vec2<i32>, vec2<i32>) -> vec2<i32>,
    ],
    conclude: ArgumentType,
} 
14:25:28 [DEBUG] naga::proc::typifier                      : overloads after arg 1 of type vec2<i32>: List {
    rules: [
        (vec2<i32>, vec2<i32>, vec2<i32>) -> vec2<i32>,
    ],
    conclude: ArgumentType,
} 
14:25:28 [DEBUG] naga::proc::typifier                      : 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,
} 
14:25:28 [DEBUG] naga::proc::typifier                      : overloads after arg 0 of type vec2<i32>: List {
    rules: [
        (vec2<i32>, vec2<i32>, vec2<i32>) -> vec2<i32>,
    ],
    conclude: ArgumentType,
} 
14:25:28 [DEBUG] naga::proc::typifier                      : overloads after arg 1 of type vec2<i32>: List {
    rules: [
        (vec2<i32>, vec2<i32>, vec2<i32>) -> vec2<i32>,
    ],
    conclude: ArgumentType,
} 
14:25:28 [DEBUG] naga::proc::typifier                      : 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,
} 
14:25:28 [DEBUG] naga::proc::typifier                      : overloads after arg 0 of type vec2<i32>: List {
    rules: [
        (vec2<i32>, vec2<i32>, vec2<i32>) -> vec2<i32>,
    ],
    conclude: ArgumentType,
} 
14:25:28 [DEBUG] naga::proc::typifier                      : overloads after arg 1 of type vec2<i32>: List {
    rules: [
        (vec2<i32>, vec2<i32>, vec2<i32>) -> vec2<i32>,
    ],
    conclude: ArgumentType,
} 
14:25:28 [DEBUG] naga::proc::typifier                      : 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,
} 
14:25:28 [DEBUG] naga::proc::typifier                      : overloads after arg 0 of type vec2<i32>: List {
    rules: [
        (vec2<i32>, vec2<i32>, vec2<i32>) -> vec2<i32>,
    ],
    conclude: ArgumentType,
} 
14:25:28 [DEBUG] naga::proc::typifier                      : overloads after arg 1 of type vec2<i32>: List {
    rules: [
        (vec2<i32>, vec2<i32>, vec2<i32>) -> vec2<i32>,
    ],
    conclude: ArgumentType,
} 
14:25:28 [DEBUG] naga::proc::typifier                      : 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>,
] 
14:25:28 [DEBUG] naga::proc::overloads::list               : arg 0 of type vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat} 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat} 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, {AbstractFloat}) -> vec2<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, {AbstractFloat}) -> vec3<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, {AbstractFloat}) -> vec4<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f32, f32, f32) -> f32 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f32, f32, f32) -> f32 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f32>, vec2<f32>, f32) -> vec2<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f32>, vec3<f32>, f32) -> vec3<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f16, f16, f16) -> f16 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f16, f16, f16) -> f16 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f16>, vec2<f16>, f16) -> vec2<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f16>, vec3<f16>, f16) -> vec3<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f16>, vec4<f16>, f16) -> vec4<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f64, f64, f64) -> f64 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f64, f64, f64) -> f64 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f64>, vec2<f64>, f64) -> vec2<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f64>, vec3<f64>, f64) -> vec3<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f64>, vec4<f64>, f64) -> vec4<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::typifier                      : overloads after arg 0 of type vec4<f32>: [
    (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
    (vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
] 
14:25:28 [DEBUG] naga::proc::overloads::list               : arg 1 of type vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::proc::typifier                      : overloads after arg 1 of type vec4<f32>: [
    (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
    (vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
] 
14:25:28 [DEBUG] naga::proc::typifier                      : 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>,
] 
14:25:28 [DEBUG] naga::proc::overloads::list               : arg 0 of type vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat} 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat} 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, {AbstractFloat}) -> vec2<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, {AbstractFloat}) -> vec3<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, {AbstractFloat}) -> vec4<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f32, f32, f32) -> f32 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f32, f32, f32) -> f32 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f32>, vec2<f32>, f32) -> vec2<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f32>, vec3<f32>, f32) -> vec3<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f16, f16, f16) -> f16 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f16, f16, f16) -> f16 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f16>, vec2<f16>, f16) -> vec2<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f16>, vec3<f16>, f16) -> vec3<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f16>, vec4<f16>, f16) -> vec4<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f64, f64, f64) -> f64 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f64, f64, f64) -> f64 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f64>, vec2<f64>, f64) -> vec2<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f64>, vec3<f64>, f64) -> vec3<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f64>, vec4<f64>, f64) -> vec4<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::typifier                      : overloads after arg 0 of type vec4<f32>: [
    (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
    (vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
] 
14:25:28 [DEBUG] naga::proc::overloads::list               : arg 1 of type vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::proc::typifier                      : overloads after arg 1 of type vec4<f32>: [
    (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
    (vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
] 
14:25:28 [DEBUG] naga::proc::typifier                      : 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>,
] 
14:25:28 [DEBUG] naga::proc::overloads::list               : arg 0 of type vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat} 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat} 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, {AbstractFloat}) -> vec2<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, {AbstractFloat}) -> vec3<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, {AbstractFloat}) -> vec4<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f32, f32, f32) -> f32 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f32, f32, f32) -> f32 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f32>, vec2<f32>, f32) -> vec2<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f32>, vec3<f32>, f32) -> vec3<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f16, f16, f16) -> f16 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f16, f16, f16) -> f16 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f16>, vec2<f16>, f16) -> vec2<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f16>, vec3<f16>, f16) -> vec3<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f16>, vec4<f16>, f16) -> vec4<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f64, f64, f64) -> f64 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f64, f64, f64) -> f64 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f64>, vec2<f64>, f64) -> vec2<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f64>, vec3<f64>, f64) -> vec3<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f64>, vec4<f64>, f64) -> vec4<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::typifier                      : overloads after arg 0 of type vec4<f32>: [
    (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
    (vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
] 
14:25:28 [DEBUG] naga::proc::overloads::list               : arg 1 of type vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::proc::typifier                      : overloads after arg 1 of type vec4<f32>: [
    (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
    (vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
] 
14:25:28 [DEBUG] naga::valid::expression                   : initial overloads for Fract: 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,
} 
14:25:28 [DEBUG] naga::valid::expression                   : overloads after arg 0: List {
    rules: [
        (vec2<f32>) -> vec2<f32>,
    ],
    conclude: ArgumentType,
} 
14:25:28 [DEBUG] naga::valid::expression                   : 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,
} 
14:25:28 [DEBUG] naga::valid::expression                   : overloads after arg 0: List {
    rules: [
        (vec2<f32>) -> vec2<f32>,
    ],
    conclude: ArgumentType,
} 
14:25:28 [DEBUG] naga::valid::expression                   : 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,
} 
14:25:28 [DEBUG] naga::valid::expression                   : overloads after arg 0: List {
    rules: [
        (vec2<i32>, vec2<i32>, vec2<i32>) -> vec2<i32>,
    ],
    conclude: ArgumentType,
} 
14:25:28 [DEBUG] naga::valid::expression                   : overloads after arg 1: List {
    rules: [
        (vec2<i32>, vec2<i32>, vec2<i32>) -> vec2<i32>,
    ],
    conclude: ArgumentType,
} 
14:25:28 [DEBUG] naga::valid::expression                   : overloads after arg 2: List {
    rules: [
        (vec2<i32>, vec2<i32>, vec2<i32>) -> vec2<i32>,
    ],
    conclude: ArgumentType,
} 
14:25:28 [DEBUG] naga::valid::expression                   : 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,
} 
14:25:28 [DEBUG] naga::valid::expression                   : overloads after arg 0: List {
    rules: [
        (vec2<i32>, vec2<i32>, vec2<i32>) -> vec2<i32>,
    ],
    conclude: ArgumentType,
} 
14:25:28 [DEBUG] naga::valid::expression                   : overloads after arg 1: List {
    rules: [
        (vec2<i32>, vec2<i32>, vec2<i32>) -> vec2<i32>,
    ],
    conclude: ArgumentType,
} 
14:25:28 [DEBUG] naga::valid::expression                   : overloads after arg 2: List {
    rules: [
        (vec2<i32>, vec2<i32>, vec2<i32>) -> vec2<i32>,
    ],
    conclude: ArgumentType,
} 
14:25:28 [DEBUG] naga::valid::expression                   : 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,
} 
14:25:28 [DEBUG] naga::valid::expression                   : overloads after arg 0: List {
    rules: [
        (vec2<i32>, vec2<i32>, vec2<i32>) -> vec2<i32>,
    ],
    conclude: ArgumentType,
} 
14:25:28 [DEBUG] naga::valid::expression                   : overloads after arg 1: List {
    rules: [
        (vec2<i32>, vec2<i32>, vec2<i32>) -> vec2<i32>,
    ],
    conclude: ArgumentType,
} 
14:25:28 [DEBUG] naga::valid::expression                   : overloads after arg 2: List {
    rules: [
        (vec2<i32>, vec2<i32>, vec2<i32>) -> vec2<i32>,
    ],
    conclude: ArgumentType,
} 
14:25:28 [DEBUG] naga::valid::expression                   : 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,
} 
14:25:28 [DEBUG] naga::valid::expression                   : overloads after arg 0: List {
    rules: [
        (vec2<i32>, vec2<i32>, vec2<i32>) -> vec2<i32>,
    ],
    conclude: ArgumentType,
} 
14:25:28 [DEBUG] naga::valid::expression                   : overloads after arg 1: List {
    rules: [
        (vec2<i32>, vec2<i32>, vec2<i32>) -> vec2<i32>,
    ],
    conclude: ArgumentType,
} 
14:25:28 [DEBUG] naga::valid::expression                   : overloads after arg 2: List {
    rules: [
        (vec2<i32>, vec2<i32>, vec2<i32>) -> vec2<i32>,
    ],
    conclude: ArgumentType,
} 
14:25:28 [DEBUG] naga::valid::expression                   : 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>,
] 
14:25:28 [DEBUG] naga::proc::overloads::list               : arg 0 of type vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat} 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat} 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, {AbstractFloat}) -> vec2<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, {AbstractFloat}) -> vec3<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, {AbstractFloat}) -> vec4<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f32, f32, f32) -> f32 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f32, f32, f32) -> f32 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f32>, vec2<f32>, f32) -> vec2<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f32>, vec3<f32>, f32) -> vec3<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f16, f16, f16) -> f16 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f16, f16, f16) -> f16 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f16>, vec2<f16>, f16) -> vec2<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f16>, vec3<f16>, f16) -> vec3<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f16>, vec4<f16>, f16) -> vec4<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f64, f64, f64) -> f64 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f64, f64, f64) -> f64 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f64>, vec2<f64>, f64) -> vec2<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f64>, vec3<f64>, f64) -> vec3<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f64>, vec4<f64>, f64) -> vec4<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::valid::expression                   : overloads after arg 0: [
    (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
    (vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
] 
14:25:28 [DEBUG] naga::proc::overloads::list               : arg 1 of type vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::valid::expression                   : overloads after arg 1: [
    (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
    (vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
] 
14:25:28 [DEBUG] naga::proc::overloads::list               : arg 2 of type f32 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::valid::expression                   : overloads after arg 2: [
    (vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
] 
14:25:28 [DEBUG] naga::valid::expression                   : 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>,
] 
14:25:28 [DEBUG] naga::proc::overloads::list               : arg 0 of type vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat} 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat} 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, {AbstractFloat}) -> vec2<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, {AbstractFloat}) -> vec3<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, {AbstractFloat}) -> vec4<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f32, f32, f32) -> f32 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f32, f32, f32) -> f32 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f32>, vec2<f32>, f32) -> vec2<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f32>, vec3<f32>, f32) -> vec3<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f16, f16, f16) -> f16 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f16, f16, f16) -> f16 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f16>, vec2<f16>, f16) -> vec2<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f16>, vec3<f16>, f16) -> vec3<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f16>, vec4<f16>, f16) -> vec4<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f64, f64, f64) -> f64 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f64, f64, f64) -> f64 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f64>, vec2<f64>, f64) -> vec2<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f64>, vec3<f64>, f64) -> vec3<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f64>, vec4<f64>, f64) -> vec4<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::valid::expression                   : overloads after arg 0: [
    (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
    (vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
] 
14:25:28 [DEBUG] naga::proc::overloads::list               : arg 1 of type vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::valid::expression                   : overloads after arg 1: [
    (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
    (vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
] 
14:25:28 [DEBUG] naga::proc::overloads::list               : arg 2 of type f32 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::valid::expression                   : overloads after arg 2: [
    (vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
] 
14:25:28 [DEBUG] naga::valid::expression                   : 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>,
] 
14:25:28 [DEBUG] naga::proc::overloads::list               : arg 0 of type vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat} 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule ({AbstractFloat}, {AbstractFloat}, {AbstractFloat}) -> {AbstractFloat} 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, vec2<{AbstractFloat}>) -> vec2<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<{AbstractFloat}>, vec2<{AbstractFloat}>, {AbstractFloat}) -> vec2<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, vec3<{AbstractFloat}>) -> vec3<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<{AbstractFloat}>, vec3<{AbstractFloat}>, {AbstractFloat}) -> vec3<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, vec4<{AbstractFloat}>) -> vec4<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<{AbstractFloat}>, vec4<{AbstractFloat}>, {AbstractFloat}) -> vec4<{AbstractFloat}> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f32, f32, f32) -> f32 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f32, f32, f32) -> f32 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f32>, vec2<f32>, vec2<f32>) -> vec2<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f32>, vec2<f32>, f32) -> vec2<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f32>, vec3<f32>, vec3<f32>) -> vec3<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f32>, vec3<f32>, f32) -> vec3<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f16, f16, f16) -> f16 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f16, f16, f16) -> f16 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f16>, vec2<f16>, vec2<f16>) -> vec2<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f16>, vec2<f16>, f16) -> vec2<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f16>, vec3<f16>, vec3<f16>) -> vec3<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f16>, vec3<f16>, f16) -> vec3<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f16>, vec4<f16>, vec4<f16>) -> vec4<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f16>, vec4<f16>, f16) -> vec4<f16> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f64, f64, f64) -> f64 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (f64, f64, f64) -> f64 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f64>, vec2<f64>, vec2<f64>) -> vec2<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec2<f64>, vec2<f64>, f64) -> vec2<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f64>, vec3<f64>, vec3<f64>) -> vec3<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec3<f64>, vec3<f64>, f64) -> vec3<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f64>, vec4<f64>, vec4<f64>) -> vec4<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f64>, vec4<f64>, f64) -> vec4<f64> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::valid::expression                   : overloads after arg 0: [
    (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
    (vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
] 
14:25:28 [DEBUG] naga::proc::overloads::list               : arg 1 of type vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::valid::expression                   : overloads after arg 1: [
    (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32>,
    (vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
] 
14:25:28 [DEBUG] naga::proc::overloads::list               : arg 2 of type f32 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, vec4<f32>) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     no conversion possible 
14:25:28 [DEBUG] naga::proc::overloads::list               :     considering rule (vec4<f32>, vec4<f32>, f32) -> vec4<f32> 
14:25:28 [DEBUG] naga::proc::overloads::list               :     types are equivalent 
14:25:28 [DEBUG] naga::valid::expression                   : overloads after arg 2: [
    (vec4<f32>, vec4<f32>, f32) -> vec4<f32>,
] 
14:25:28 [DEBUG] naga::valid::function                     : var LocalVariable { name: Some("out_color_gamma"), ty: [2], init: None } 
14:25:28 [DEBUG] wgpu_core::device::global                 : configuring surface with SurfaceConfiguration { usage: TextureUsages(RENDER_ATTACHMENT), format: Bgra8Unorm, width: 800, height: 600, present_mode: AutoNoVsync, desired_maximum_frame_latency: 2, alpha_mode: Auto, view_formats: [Bgra8Unorm] } 
14:25:28 [DEBUG] egui_winit::clipboard                     : Cannot init smithay clipboard without a Wayland display handle 
14:25:28 [INFO ] zbus::connection::handshake::common       : write_command; command=Auth(Some(External), Some([49, 48, 48, 48])) 
14:25:28 [INFO ] zbus::connection::handshake::common       : write_commands; commands=[Auth(Some(External), Some([49, 48, 48, 48]))] extra_bytes=None 
14:25:28 [INFO ] zbus::connection::handshake::common       : read_commands; n_commands=1 
14:25:28 [INFO ] zbus::connection::handshake::common       : write_commands; commands=[NegotiateUnixFD, Begin] extra_bytes=Some([108, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 109, 0, 0, 0, 1, 1, 111, 0, 21, 0, 0, 0, 47, 111, 114, 103, 47, 102, 114, 101, 101, 100, 101, 115, 107, 116, 111, 112, 47, 68, 66, 117, 115, 0, 0, 0, 2, 1, 115, 0, 20, 0, 0, 0, 111, 114, 103, 46, 102, 114, 101, 101, 100, 101, 115, 107, 116, 111, 112, 46, 68, 66, 117, 115, 0, 0, 0, 0, 3, 1, 115, 0, 5, 0, 0, 0, 72, 101, 108, 108, 111, 0, 0, 0, 6, 1, 115, 0, 20, 0, 0, 0, 111, 114, 103, 46, 102, 114, 101, 101, 100, 101, 115, 107, 116, 111, 112, 46, 68, 66, 117, 115, 0, 0, 0, 0]) 
14:25:28 [INFO ] zbus::connection::handshake::common       : read_commands; n_commands=1 
14:25:28 [INFO ] zbus::proxy                               : {}; task_name="org.a11y.Status proxy caching" 
14:25:28 [DEBUG] winit::window                             : winit::Window::set_visible; visible=true 
14:25:28 [DEBUG] wgpu_core::device::global                 : configuring surface with SurfaceConfiguration { usage: TextureUsages(RENDER_ATTACHMENT), format: Bgra8Unorm, width: 941, height: 1160, present_mode: AutoNoVsync, desired_maximum_frame_latency: 2, alpha_mode: Auto, view_formats: [Bgra8Unorm] } 
14:25:28 [DEBUG] winit::window                             : winit::Window::set_cursor_visible; visible=true 
14:25:36 [WARN ] idevice_pair                              : usbmuxd listen error: Socket(Custom { kind: UnexpectedEof, error: "early eof" }) 
14:25:36 [WARN ] idevice_pair                              : Failed to connect to usbmuxd for listening: Socket(Os { code: 111, kind: ConnectionRefused, message: "Connection refused" }) 
14:25:37 [WARN ] idevice_pair                              : Failed to connect to usbmuxd for listening: Socket(Os { code: 111, kind: ConnectionRefused, message: "Connection refused" }) 
14:25:37 [WARN ] idevice_pair                              : Failed to connect to usbmuxd for listening: Socket(Os { code: 111, kind: ConnectionRefused, message: "Connection refused" }) 
14:25:38 [WARN ] idevice_pair                              : Failed to connect to usbmuxd for listening: Socket(Os { code: 111, kind: ConnectionRefused, message: "Connection refused" }) 
14:25:38 [WARN ] idevice_pair                              : Failed to connect to usbmuxd for listening: Socket(Os { code: 111, kind: ConnectionRefused, message: "Connection refused" }) 
14:25:39 [WARN ] idevice_pair                              : Failed to connect to usbmuxd for listening: Socket(Os { code: 111, kind: ConnectionRefused, message: "Connection refused" }) 
14:25:39 [WARN ] idevice_pair                              : Failed to connect to usbmuxd for listening: Socket(Os { code: 111, kind: ConnectionRefused, message: "Connection refused" }) 
14:25:40 [WARN ] idevice_pair                              : Failed to connect to usbmuxd for listening: Socket(Os { code: 111, kind: ConnectionRefused, message: "Connection refused" }) 
14:25:40 [WARN ] idevice_pair                              : Failed to connect to usbmuxd for listening: Socket(Os { code: 111, kind: ConnectionRefused, message: "Connection refused" }) 
14:25:41 [WARN ] idevice_pair                              : Failed to connect to usbmuxd for listening: Socket(Os { code: 111, kind: ConnectionRefused, message: "Connection refused" }) 
14:25:41 [WARN ] idevice_pair                              : Failed to connect to usbmuxd for listening: Socket(Os { code: 111, kind: ConnectionRefused, message: "Connection refused" }) 
14:25:42 [WARN ] idevice_pair                              : Failed to connect to usbmuxd for listening: Socket(Os { code: 111, kind: ConnectionRefused, message: "Connection refused" }) 
14:25:42 [WARN ] idevice_pair                              : Failed to connect to usbmuxd for listening: Socket(Os { code: 111, kind: ConnectionRefused, message: "Connection refused" }) 
14:25:43 [WARN ] idevice_pair                              : Failed to connect to usbmuxd for listening: Socket(Os { code: 111, kind: ConnectionRefused, message: "Connection refused" }) 
14:25:43 [WARN ] idevice_pair                              : Failed to connect to usbmuxd for listening: Socket(Os { code: 111, kind: ConnectionRefused, message: "Connection refused" }) 
14:25:44 [WARN ] idevice_pair                              : Failed to connect to usbmuxd for listening: Socket(Os { code: 111, kind: ConnectionRefused, message: "Connection refused" }) 
14:25:44 [WARN ] idevice_pair                              : Failed to connect to usbmuxd for listening: Socket(Os { code: 111, kind: ConnectionRefused, message: "Connection refused" }) 
14:25:45 [WARN ] idevice_pair                              : Failed to connect to usbmuxd for listening: Socket(Os { code: 111, kind: ConnectionRefused, message: "Connection refused" }) 
14:25:45 [WARN ] idevice_pair                              : Failed to connect to usbmuxd for listening: Socket(Os { code: 111, kind: ConnectionRefused, message: "Connection refused" }) 
14:25:46 [WARN ] idevice_pair                              : Failed to connect to usbmuxd for listening: Socket(Os { code: 111, kind: ConnectionRefused, message: "Connection refused" }) 
14:25:46 [WARN ] idevice_pair                              : Failed to connect to usbmuxd for listening: Socket(Os { code: 111, kind: ConnectionRefused, message: "Connection refused" }) 
14:25:47 [WARN ] idevice_pair                              : Failed to connect to usbmuxd for listening: Socket(Os { code: 111, kind: ConnectionRefused, message: "Connection refused" }) 
14:25:47 [WARN ] idevice_pair                              : Failed to connect to usbmuxd for listening: Socket(Os { code: 111, kind: ConnectionRefused, message: "Connection refused" }) 
14:25:48 [WARN ] idevice_pair                              : Failed to connect to usbmuxd for listening: Socket(Os { code: 111, kind: ConnectionRefused, message: "Connection refused" }) 
14:25:48 [WARN ] idevice_pair                              : Failed to connect to usbmuxd for listening: Socket(Os { code: 111, kind: ConnectionRefused, message: "Connection refused" }) 
14:25:49 [WARN ] idevice_pair                              : Failed to connect to usbmuxd for listening: Socket(Os { code: 111, kind: ConnectionRefused, message: "Connection refused" }) 
14:25:49 [WARN ] idevice_pair                              : Failed to connect to usbmuxd for listening: Socket(Os { code: 111, kind: ConnectionRefused, message: "Connection refused" }) 
14:25:50 [WARN ] idevice_pair                              : Failed to connect to usbmuxd for listening: Socket(Os { code: 111, kind: ConnectionRefused, message: "Connection refused" }) 
14:25:50 [WARN ] idevice_pair                              : Failed to connect to usbmuxd for listening: Socket(Os { code: 111, kind: ConnectionRefused, message: "Connection refused" }) 
14:25:51 [WARN ] idevice_pair                              : Failed to connect to usbmuxd for listening: Socket(Os { code: 111, kind: ConnectionRefused, message: "Connection refused" }) 
14:25:51 [WARN ] idevice_pair                              : Failed to connect to usbmuxd for listening: Socket(Os { code: 111, kind: ConnectionRefused, message: "Connection refused" }) 
14:25:52 [WARN ] idevice_pair                              : Failed to connect to usbmuxd for listening: Socket(Os { code: 111, kind: ConnectionRefused, message: "Connection refused" }) 
14:25:52 [WARN ] idevice_pair                              : Failed to connect to usbmuxd for listening: Socket(Os { code: 111, kind: ConnectionRefused, message: "Connection refused" }) 
14:25:53 [WARN ] idevice_pair                              : Failed to connect to usbmuxd for listening: Socket(Os { code: 111, kind: ConnectionRefused, message: "Connection refused" }) 
14:25:53 [WARN ] idevice_pair                              : Failed to connect to usbmuxd for listening: Socket(Os { code: 111, kind: ConnectionRefused, message: "Connection refused" }) 
14:25:54 [WARN ] idevice_pair                              : Failed to connect to usbmuxd for listening: Socket(Os { code: 111, kind: ConnectionRefused, message: "Connection refused" }) 
14:25:54 [DEBUG] idevice::usbmuxd                          : Reading 278 bytes from muxer 
14:25:54 [DEBUG] idevice::usbmuxd                          : Read from muxer: {
MessageType: "Result",
Number: 0
} 
14:26:14 [DEBUG] idevice::usbmuxd                          : Reading 282 bytes from muxer 
14:26:14 [DEBUG] idevice::usbmuxd                          : Read from muxer: {
MessageType: "Detached",
DeviceID: 1
} 
14:26:14 [DEBUG] idevice::usbmuxd                          : Reading 221 bytes from muxer 
14:26:14 [DEBUG] idevice::usbmuxd                          : Read from muxer: {
DeviceList: [

  ]
} 
14:26:21 [DEBUG] idevice::usbmuxd                          : Reading 650 bytes from muxer 
14:26:21 [DEBUG] idevice::usbmuxd                          : Read from muxer: {
MessageType: "Attached",
DeviceID: 2,
Properties: {
    ConnectionSpeed: 480000000,
    ConnectionType: "USB",
    DeviceID: 2,
    LocationID: 458782,
    ProductID: 4776,
    SerialNumber: "00008140-001C396E1E13001C"
  }
} 
14:26:21 [DEBUG] idevice::usbmuxd::des                     : Connection type: Usb 
14:26:21 [DEBUG] idevice::usbmuxd                          : Reading 749 bytes from muxer 
14:26:21 [DEBUG] idevice::usbmuxd                          : Read from muxer: {
DeviceList: [
    {
      MessageType: "Attached",
      DeviceID: 2,
      Properties: {
        ConnectionSpeed: 480000000,
        ConnectionType: "USB",
        DeviceID: 2,
        LocationID: 458782,
        ProductID: 4776,
        SerialNumber: "00008140-001C396E1E13001C"
      }
    }
  ]
} 
14:26:21 [DEBUG] idevice::usbmuxd::des                     : Connection type: Usb 
14:26:21 [DEBUG] idevice::usbmuxd                          : Connecting to device 2 on port 62078 
14:26:21 [DEBUG] idevice::usbmuxd                          : Reading 278 bytes from muxer 
14:26:21 [DEBUG] idevice::usbmuxd                          : Read from muxer: {
MessageType: "Result",
Number: 0
} 
14:26:21 [DEBUG] idevice                                   : Sending plist: {
  Label: "idevice_pair",
  Request: "GetValue"
} 
14:26:21 [DEBUG] idevice                                   : Reading response size 
14:26:21 [DEBUG] idevice                                   : Received plist: {
Request: "GetValue",
Value: {
    BasebandCertId: 1652214800,
    BasebandKeyHashInformation: {
      AKeyStatus: 2,
      SKeyHash: Data(00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00... Len: 32),
      SKeyStatus: 0
    },
    BasebandSerialNumber: Data(AC E2 3C B4 Len: 4),
    BasebandVersion: "2.20.04",
    BoardId: 8,
    BuildVersion: "23C55",
    CPUArchitecture: "arm64e",
    ChipID: 33088,
    DeviceClass: "iPhone",
    DeviceColor: "1",
    DeviceName: "Matthew’s iPhone",
    DieID: 7944444461645852,
    HardwareModel: "D47AP",
    HasSiDP: true,
    HumanReadableProductVersionString: "26.2",
    PartitionType: "GUID_partition_scheme",
    ProductName: "iPhone OS",
    ProductType: "iPhone17,3",
    ProductVersion: "26.2",
    ProductionSOC: true,
    ProtocolVersion: "2",
    SupportedDeviceFamilies: [
      1
    ],
    TelephonyCapability: true,
    UniqueChipID: 7944444461645852,
    UniqueDeviceID: "00008140-001C396E1E13001C",
    UntrustedHostBUID: "50D4336F-B1C9-D208-5424-6F2E06DB6102",
    WiFiAddress: "14:35:b7:1b:51:36"
  }
} 
14:26:27 [DEBUG] idevice::usbmuxd                          : Connecting to device 2 on port 62078 
14:26:28 [DEBUG] winit::window                             : winit::Window::set_cursor_visible; visible=true 
14:26:28 [DEBUG] winit::window                             : winit::Window::set_cursor_visible; visible=true 
14:26:28 [DEBUG] winit::window                             : winit::Window::set_cursor_visible; visible=true 
14:26:28 [DEBUG] winit::window                             : winit::Window::set_cursor_visible; visible=true 
(this appears thousands more times

usbmuxd:

14:25:54.529][3] usbmuxd v1.1.1 starting up
[14:25:54.529][4] Creating socket
[14:25:54.529][4] Initializing USB
[14:25:54.529][3] Using libusb 1.0.29
[14:25:54.542][4] Registering for libusb hotplug events
[14:25:54.542][4] Found new device with v/p 05ac:12a8 at 7-29
libusb: warning [op_get_configuration] device unconfigured
libusb: error [op_get_active_config_descriptor] device unconfigured
[14:25:54.542][3] Could not get old configuration descriptor for device 7-29: LIBUSB_ERROR_NOT_FOUND
[14:25:54.542][4] Setting configuration for device 7-29, from 0 to 4
[14:25:54.612][4] Found interface 1 with endpoints 04/85 for device 7-29
[14:25:54.612][4] Using wMaxPacketSize=512 for device 7-29
[14:25:54.612][4] USB Speed is 480 MBit/s for device 7-29
[14:25:54.612][4] 1 device detected
[14:25:54.612][3] Initialization complete
[14:25:54.616][4] Got lang ID 1033 for device 7-29
[14:25:54.621][4] Got serial '00008140001C396E1E13001C' for device 7-29
[14:25:54.621][3] Connecting to new device on location 0x7001d as ID 1
[14:25:54.622][3] Connected to v2.0 device 1 on location 0x7001d with serial number 00008140-001C396E1E13001C
[14:25:54.622][4] preflight_worker_handle_device_add: Starting preflight on device 00008140-001C396E1E13001C...
[14:25:54.622][4] Client 11 accepted: usbmuxd[286697]
[14:25:54.623][4] Client connected to device 1 (1->62078)
[14:25:54.910][4] Client 12 accepted: ./idevice_pair[285892]
[14:26:14.323][4] Device 7-29 RX aborted due to disconnect
[14:26:14.323][4] Device 7-29 RX aborted due to disconnect
[14:26:14.323][4] Device 7-29 RX aborted due to disconnect
[14:26:14.323][3] Removed device 1 on location 0x7001d
[14:26:14.323][4] Client 11 is going to be disconnected: usbmuxd[286697]
[14:26:14.323][1] preflight_worker_handle_device_add: ERROR: Could not get lockdownd type from device 00008140-001C396E1E13001C, lockdown error -256
[14:26:14.323][4] Client 9 accepted: ./idevice_pair[285892]
[14:26:14.323][4] Client 9 connection closed
[14:26:14.323][4] Client 9 is going to be disconnected: ./idevice_pair[285892]
[14:26:14.332][4] Caught SIGUSR1/2 but this instance was not started with "--enable-exit", ignoring.
[14:26:20.916][4] Found new device with v/p 05ac:12a8 at 7-30
libusb: warning [op_get_configuration] device unconfigured
libusb: error [op_get_active_config_descriptor] device unconfigured
[14:26:20.916][3] Could not get old configuration descriptor for device 7-30: LIBUSB_ERROR_NOT_FOUND
[14:26:20.916][4] Setting configuration for device 7-30, from 0 to 4
[14:26:20.987][4] Found interface 1 with endpoints 04/85 for device 7-30
[14:26:20.987][4] Using wMaxPacketSize=512 for device 7-30
[14:26:20.987][4] USB Speed is 480 MBit/s for device 7-30
[14:26:20.990][4] Got lang ID 1033 for device 7-30
[14:26:20.996][4] Got serial '00008140001C396E1E13001C' for device 7-30
[14:26:20.996][3] Connecting to new device on location 0x7001e as ID 2
[14:26:20.997][3] Connected to v2.0 device 2 on location 0x7001e with serial number 00008140-001C396E1E13001C
[14:26:20.997][4] preflight_worker_handle_device_add: Starting preflight on device 00008140-001C396E1E13001C...
[14:26:20.998][4] Client 11 accepted: usbmuxd[286697]
[14:26:20.998][4] Client connected to device 2 (1->62078)
[14:26:21.003][4] preflight_worker_handle_device_add: Device 00008140-001C396E1E13001C is not paired with this host.
[14:26:21.005][4] preflight_worker_handle_device_add: Found ProductVersion 26.2 device 00008140-001C396E1E13001C
[14:26:21.067][4] Client 14 accepted: usbmuxd[286697]
[14:26:21.067][4] Client 14 connection closed
[14:26:21.068][4] Client 14 is going to be disconnected: usbmuxd[286697]
[14:26:21.096][4] Client 14 accepted: usbmuxd[286697]
[14:26:21.096][4] Client connected to device 2 (2->52546)
[14:26:21.096][4] Client 11 is going to be disconnected: usbmuxd[286697]
[14:26:21.096][4] preflight_worker_handle_device_add: Waiting for user to trust this computer on device 00008140-001C396E1E13001C
[14:26:21.097][4] Client 10 accepted: ./idevice_pair[285892]
[14:26:21.097][4] Client 11 accepted: ./idevice_pair[285892]
[14:26:21.097][4] Client connected to device 2 (3->62078)
[14:26:21.112][4] Client 11 is going to be disconnected: ./idevice_pair[285892]
[14:26:21.112][4] Client 10 connection closed
[14:26:21.112][4] Client 10 is going to be disconnected: ./idevice_pair[285892]
[14:26:27.877][4] Client 10 accepted: ./idevice_pair[285892]
[14:26:27.877][4] Client 11 accepted: ./idevice_pair[285892]