#version 460
#if defined(GL_ARB_gpu_shader_int64)
#extension GL_ARB_gpu_shader_int64 : require
#else
#error No extension available for 64-bit integers.
#endif
#extension GL_EXT_buffer_reference2 : require
#extension GL_EXT_nonuniform_qualifier : require
#extension GL_EXT_scalar_block_layout : require
#extension GL_EXT_shader_atomic_int64 : require
layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;

struct DescriptorHeapRawPayload
{
    uvec2 _m0[1];
};

struct IAddCarryResult
{
    uint _m0;
    uint _m1;
};

layout(set = 0, binding = 0, std430) buffer DescriptorHeapRobustnessSSBO
{
    DescriptorHeapRawPayload descriptors[];
} DescriptorHeapRobustness;

layout(set = 1, binding = 0, scalar) restrict readonly buffer SSBO
{
    uvec3 _m0[];
} _24[];

layout(set = 4, binding = 0, std430) buffer _26_29
{
    uint _m0[];
} _29[];

layout(set = 0, binding = 2, std430) buffer BloomBufferInvocationSSBO
{
    uint atomics[];
} BloomBufferInvocation;

layout(set = 0, binding = 2, std430) buffer BloomBufferSSBO
{
    uint64_t atomics[];
} BloomBuffer;

layout(set = 0, binding = 2, std430) buffer BloomBuffer32SSBO
{
    uvec2 atomics[];
} BloomBuffer32;

layout(set = 0, binding = 2, std430) buffer InstrumentationControlDataSSBO
{
    uint atomics[];
} InstrumentationControlData;

layout(set = 0, binding = 3, std430) buffer InstrumentationDataSSBO
{
    uvec4 data[];
} InstrumentationData;

layout(push_constant, std430) uniform RootConstants
{
    uint _m0;
    uint _m1;
    uint _m2;
    uint _m3;
    uint _m4;
    uint _m5;
    uint _m6;
    uint _m7;
} registers;

uint InvocationID;
bool ShouldReportInstrumentation = true;

uint AllocateInvocationID()
{
    uint _42 = atomicAdd(BloomBufferInvocation.atomics[uint(BloomBufferInvocation.atomics.length()) - 1u], 1103633207u);
    return _42;
}

uint AddrHash(uvec2 addr, uint prime)
{
    uvec2 _87 = uvec2(addr.x >> 4u, addr.y & 65535u);
    uvec2 _88 = uvec2(prime);
    uvec2 _95 = ((_87 >> uvec2(8u)) ^ _87.yx) * _88;
    uvec2 _99 = ((_95 >> uvec2(8u)) ^ _95.yx) * _88;
    uvec2 _103 = ((_99 >> uvec2(8u)) ^ _99.yx) * _88;
    uvec2 _107 = ((_103 >> uvec2(8u)) ^ _103.yx) * _88;
    uvec2 _111 = ((_107 >> uvec2(8u)) ^ _107.yx) * _88;
    return (((_111 >> uvec2(8u)) ^ _111.yx) * _88).x;
}

bool ValidateBDALoadStore(uvec2 BDA, uint offset, uint len, uint type, uint invocation_id, bool in_bounds)
{
    if (!in_bounds)
    {
        return true;
    }
    IAddCarryResult _144;
    _144._m0 = uaddCarry(BDA.x, offset, _144._m1);
    uvec2 addr = uvec2(_144._m0, BDA.y + _144._m1);
    uint addr_lo = addr.x;
    uint byte_mask = (bitfieldExtract(4294967295u, int(0u), int(len)) << (addr_lo & 15u)) & 65535u;
    uint word_mask = (bitfieldExtract(4294967295u, int(0u), int((((addr_lo & 3u) + len) + 3u) >> 2u)) << bitfieldExtract(addr_lo, int(2u), int(2u))) & 15u;
    uint hash_mask = bitfieldExtract(4294967295u, int(0u), int(uint(findMSB(uint(BloomBuffer.atomics.length())))));
    uint hash_offset = bitfieldExtract(uint(BloomBuffer.atomics.length()), int(0u), int(uint(findMSB(uint(BloomBuffer.atomics.length()))))) - 1u;
    uint bloom_index = (AddrHash(addr, 1103515245u) & hash_mask) + hash_offset;
    uint bloom_index_1 = (AddrHash(addr, 1103518333u) & hash_mask) + hash_offset;
    uint bloom_index_2 = (AddrHash(addr, 1103539331u) & hash_mask) + hash_offset;
    uint bloom_index_3 = (AddrHash(addr, 1103633207u) & hash_mask) + hash_offset;
    uint bloom_index_4 = (AddrHash(addr, 10006121u) & hash_mask) + hash_offset;
    uint bloom_index_5 = (AddrHash(addr, 4004951u) & hash_mask) + hash_offset;
    uint bloom_index_6 = (AddrHash(addr, 5005159u) & hash_mask) + hash_offset;
    uint bloom_index_7 = (AddrHash(addr, 6004811u) & hash_mask) + hash_offset;
    uint64_t invalidation_mask = u64vec4(68719411200ul, 1099511627775ul, 1035087118335ul, 68719411200ul)[type] & packUint2x32(uvec2(byte_mask | (byte_mask << 16u), word_mask | (word_mask << 4u)));
    uint64_t prev_hazard_partial = atomicOr(BloomBuffer.atomics[bloom_index], invalidation_mask);
    uint64_t prev_hazard_partial_1 = atomicOr(BloomBuffer.atomics[bloom_index_1], invalidation_mask);
    uint64_t prev_hazard_partial_2 = atomicOr(BloomBuffer.atomics[bloom_index_2], invalidation_mask);
    uint64_t prev_hazard_partial_3 = atomicOr(BloomBuffer.atomics[bloom_index_3], invalidation_mask);
    uint64_t prev_hazard_partial_4 = atomicOr(BloomBuffer.atomics[bloom_index_4], invalidation_mask);
    uint64_t prev_hazard_partial_5 = atomicOr(BloomBuffer.atomics[bloom_index_5], invalidation_mask);
    uint64_t prev_hazard_partial_6 = atomicOr(BloomBuffer.atomics[bloom_index_6], invalidation_mask);
    uint64_t prev_hazard_partial_7 = atomicOr(BloomBuffer.atomics[bloom_index_7], invalidation_mask);
    uint64_t prev_hazard_partial_8 = atomicOr(BloomBuffer.atomics[(AddrHash(addr, 383u) & hash_mask) + hash_offset], invalidation_mask);
    uint64_t prev_hazard_partial_9 = atomicOr(BloomBuffer.atomics[(AddrHash(addr, 821u) & hash_mask) + hash_offset], invalidation_mask);
    uint64_t prev_hazard_partial_10 = atomicOr(BloomBuffer.atomics[(AddrHash(addr, 661u) & hash_mask) + hash_offset], invalidation_mask);
    uint64_t prev_hazard_partial_11 = atomicOr(BloomBuffer.atomics[(AddrHash(addr, 1091u) & hash_mask) + hash_offset], invalidation_mask);
    uint64_t prev_hazard_partial_12 = atomicOr(BloomBuffer.atomics[(AddrHash(addr, 1117u) & hash_mask) + hash_offset], invalidation_mask);
    uint64_t prev_hazard_partial_13 = atomicOr(BloomBuffer.atomics[(AddrHash(addr, 3947u) & hash_mask) + hash_offset], invalidation_mask);
    uint64_t prev_hazard_partial_14 = atomicOr(BloomBuffer.atomics[(AddrHash(addr, 4253u) & hash_mask) + hash_offset], invalidation_mask);
    uint64_t prev_hazard_partial_15 = atomicOr(BloomBuffer.atomics[(AddrHash(addr, 7691u) & hash_mask) + hash_offset], invalidation_mask);
    uvec2 prev_hazard = unpackUint2x32(((((((((((((((prev_hazard_partial & prev_hazard_partial_1) & prev_hazard_partial_2) & prev_hazard_partial_3) & prev_hazard_partial_4) & prev_hazard_partial_5) & prev_hazard_partial_6) & prev_hazard_partial_7) & prev_hazard_partial_8) & prev_hazard_partial_9) & prev_hazard_partial_10) & prev_hazard_partial_11) & prev_hazard_partial_12) & prev_hazard_partial_13) & prev_hazard_partial_14) & prev_hazard_partial_15);
    uint prev_hazard_lo = prev_hazard.x;
    uint prev_hazard_hi = prev_hazard.y;
    bool has_exclusive_access = ((prev_hazard_lo >> 16u) & byte_mask) == 0u;
    uint lock_mask = ((256u << bitfieldExtract(invocation_id, 0, 3)) | (65536u << bitfieldExtract(invocation_id, 3, 3))) | (16777216u << bitfieldExtract(invocation_id, 6, 3));
    uint prev_lock = atomicOr(BloomBuffer32.atomics[bloom_index].y, has_exclusive_access ? lock_mask : 0u);
    uint lock_mask_1 = ((256u << bitfieldExtract(invocation_id, 9, 3)) | (65536u << bitfieldExtract(invocation_id, 12, 3))) | (16777216u << bitfieldExtract(invocation_id, 15, 3));
    uint prev_lock_1 = atomicOr(BloomBuffer32.atomics[bloom_index_1].y, has_exclusive_access ? lock_mask_1 : 0u);
    uint lock_mask_2 = ((256u << bitfieldExtract(invocation_id, 18, 3)) | (65536u << bitfieldExtract(invocation_id, 21, 3))) | (16777216u << bitfieldExtract(invocation_id, 24, 3));
    uint prev_lock_2 = atomicOr(BloomBuffer32.atomics[bloom_index_2].y, has_exclusive_access ? lock_mask_2 : 0u);
    uint lock_mask_3 = ((256u << bitfieldExtract(invocation_id, 23, 3)) | (65536u << bitfieldExtract(invocation_id, 26, 3))) | (16777216u << bitfieldExtract(invocation_id, 29, 3));
    uint prev_lock_3 = atomicOr(BloomBuffer32.atomics[bloom_index_3].y, has_exclusive_access ? lock_mask_3 : 0u);
    uint lock_mask_4 = ((256u << bitfieldExtract(invocation_id, 1, 3)) | (65536u << bitfieldExtract(invocation_id, 4, 3))) | (16777216u << bitfieldExtract(invocation_id, 7, 3));
    uint prev_lock_4 = atomicOr(BloomBuffer32.atomics[bloom_index_4].y, has_exclusive_access ? lock_mask_4 : 0u);
    uint lock_mask_5 = ((256u << bitfieldExtract(invocation_id, 9, 3)) | (65536u << bitfieldExtract(invocation_id, 12, 3))) | (16777216u << bitfieldExtract(invocation_id, 15, 3));
    uint prev_lock_5 = atomicOr(BloomBuffer32.atomics[bloom_index_5].y, has_exclusive_access ? lock_mask_5 : 0u);
    uint lock_mask_6 = ((256u << bitfieldExtract(invocation_id, 17, 3)) | (65536u << bitfieldExtract(invocation_id, 20, 3))) | (16777216u << bitfieldExtract(invocation_id, 23, 3));
    uint prev_lock_6 = atomicOr(BloomBuffer32.atomics[bloom_index_6].y, has_exclusive_access ? lock_mask_6 : 0u);
    uint lock_mask_7 = ((256u << bitfieldExtract(invocation_id, 22, 3)) | (65536u << bitfieldExtract(invocation_id, 25, 3))) | (16777216u << bitfieldExtract(invocation_id, 28, 3));
    uint prev_lock_7 = atomicOr(BloomBuffer32.atomics[bloom_index_7].y, has_exclusive_access ? lock_mask_7 : 0u);
    bool hazard;
    switch (type)
    {
        case 0u:
        {
            hazard = (prev_hazard_lo & byte_mask) != 0u;
            break;
        }
        case 1u:
        {
            hazard = (prev_hazard_lo & (byte_mask << 16u)) != 0u;
            break;
        }
        case 2u:
        {
            hazard = (prev_hazard_hi & word_mask) != 0u;
            break;
        }
        default:
        {
            hazard = (prev_hazard_hi & (word_mask << 4u)) != 0u;
            break;
        }
    }
    return (!hazard) || (((((((((prev_lock & lock_mask) == lock_mask) && ((prev_lock_1 & lock_mask_1) == lock_mask_1)) && ((prev_lock_2 & lock_mask_2) == lock_mask_2)) && ((prev_lock_3 & lock_mask_3) == lock_mask_3)) && ((prev_lock_4 & lock_mask_4) == lock_mask_4)) && ((prev_lock_5 & lock_mask_5) == lock_mask_5)) && ((prev_lock_6 & lock_mask_6) == lock_mask_6)) && ((prev_lock_7 & lock_mask_7) == lock_mask_7));
}

void AssumeTrue(bool value, uint inst)
{
    if ((!value) && ShouldReportInstrumentation)
    {
        uint _517 = uint(InstrumentationControlData.atomics.length()) - 2u;
        uint _519 = InstrumentationControlData.atomics[_517];
        uint _525 = (((inst * 97u) ^ 43981u) ^ (_519 * 51329u)) & (uint(InstrumentationData.data.length()) - 1u);
        uint _526 = _525 >> 4u;
        uint _528 = 1u << (_525 & 15u);
        uint _530 = atomicOr(InstrumentationControlData.atomics[_526], _528);
        ShouldReportInstrumentation = false;
        if ((_530 & _528) == 0u)
        {
            InstrumentationData.data[_525] = uvec4(43981u, 0u, inst, _519);
            memoryBarrierBuffer();
            uint _538 = atomicOr(InstrumentationControlData.atomics[_526], _528 << 16u);
            memoryBarrierBuffer();
        }
    }
}

void main()
{
    uint _45 = AllocateInvocationID();
    InvocationID = _45;
    uvec2 _54 = DescriptorHeapRobustness.descriptors[registers._m4]._m0[0u];
    uint _59 = uint(_29[registers._m4]._m0.length()) * 4u;
    uvec2 _65 = DescriptorHeapRobustness.descriptors[registers._m1]._m0[0u];
    uint _77 = (gl_GlobalInvocationID.x * 12u) + 0u;
    uint _459 = InvocationID;
    bool _458 = ValidateBDALoadStore(_65, _77, 12u, 0u, _459, _77 < (uint(_24[registers._m1]._m0.length()) * 12u));
    AssumeTrue(_458, 1u);
    vec3 _466 = uintBitsToFloat(_24[registers._m1]._m0[gl_GlobalInvocationID.x]);
    uint _473 = (gl_GlobalInvocationID.x * 4u) + 0u;
    uint _475 = InvocationID;
    bool _474 = ValidateBDALoadStore(_54, _473, 4u, 0u, _475, _473 < _59);
    AssumeTrue(_474, 2u);
    uint _478 = _29[registers._m4]._m0[gl_GlobalInvocationID.x];
    uint _482 = (gl_GlobalInvocationID.x * 4u) + 0u;
    uint _484 = InvocationID;
    bool _483 = ValidateBDALoadStore(_54, _482, 4u, 1u, _484, _482 < _59);
    AssumeTrue(_483, 3u);
    _29[registers._m4]._m0[gl_GlobalInvocationID.x] = floatBitsToUint(((_466.x + 40.0) + _466.z) + uintBitsToFloat(_478));
}


#if 0
// SPIR-V disassembly
; SPIR-V
; Version: 1.3
; Generator: Unknown(30017); 21022
; Bound: 545
; Schema: 0
OpCapability Shader
OpCapability Int64
OpCapability Int64Atomics
OpCapability SignedZeroInfNanPreserve
OpCapability RuntimeDescriptorArray
OpCapability PhysicalStorageBufferAddresses
OpExtension "SPV_EXT_descriptor_indexing"
OpExtension "SPV_KHR_float_controls"
OpExtension "SPV_KHR_physical_storage_buffer"
%169 = OpExtInstImport "GLSL.std.450"
OpMemoryModel PhysicalStorageBuffer64 GLSL450
OpEntryPoint GLCompute %3 "main" %72
OpExecutionMode %3 SignedZeroInfNanPreserve 32
OpExecutionMode %3 SignedZeroInfNanPreserve 64
OpExecutionMode %3 LocalSize 1 1 1
OpName %3 "main"
OpName %6 "RootConstants"
OpName %8 "registers"
OpName %12 "DescriptorHeapRawPayload"
OpName %14 "DescriptorHeapRobustnessSSBO"
OpMemberName %14 0 "descriptors"
OpName %16 "DescriptorHeapRobustness"
OpName %18 "InvocationID"
OpName %21 "SSBO"
OpName %26 "SSBO"
OpName %31 "BloomBufferInvocationSSBO"
OpMemberName %31 0 "atomics"
OpName %33 "BloomBufferInvocation"
OpName %35 "AllocateInvocationID"
OpName %81 "AddrHash"
OpName %79 "addr"
OpName %80 "prime"
OpName %121 "BloomBufferSSBO"
OpMemberName %121 0 "atomics"
OpName %123 "BloomBuffer"
OpName %125 "BloomBuffer32SSBO"
OpMemberName %125 0 "atomics"
OpName %127 "BloomBuffer32"
OpName %135 "ValidateBDALoadStore"
OpName %129 "BDA"
OpName %130 "offset"
OpName %131 "len"
OpName %132 "type"
OpName %133 "invocation_id"
OpName %134 "in_bounds"
OpName %143 "IAddCarryResult"
OpName %148 "addr"
OpName %149 "addr_lo"
OpName %153 "byte_mask"
OpName %163 "word_mask"
OpName %168 "hash_mask"
OpName %173 "hash_offset"
OpName %177 "bloom_index"
OpName %181 "bloom_index"
OpName %185 "bloom_index"
OpName %188 "bloom_index"
OpName %192 "bloom_index"
OpName %196 "bloom_index"
OpName %200 "bloom_index"
OpName %204 "bloom_index"
OpName %208 "bloom_index"
OpName %212 "bloom_index"
OpName %216 "bloom_index"
OpName %220 "bloom_index"
OpName %224 "bloom_index"
OpName %228 "bloom_index"
OpName %232 "bloom_index"
OpName %236 "bloom_index"
OpName %249 "invalidation_mask"
OpName %252 "prev_hazard_partial"
OpName %254 "prev_hazard_partial"
OpName %257 "prev_hazard_partial"
OpName %260 "prev_hazard_partial"
OpName %263 "prev_hazard_partial"
OpName %266 "prev_hazard_partial"
OpName %269 "prev_hazard_partial"
OpName %272 "prev_hazard_partial"
OpName %275 "prev_hazard_partial"
OpName %278 "prev_hazard_partial"
OpName %281 "prev_hazard_partial"
OpName %284 "prev_hazard_partial"
OpName %287 "prev_hazard_partial"
OpName %290 "prev_hazard_partial"
OpName %293 "prev_hazard_partial"
OpName %296 "prev_hazard_partial"
OpName %298 "prev_hazard"
OpName %299 "prev_hazard_lo"
OpName %300 "prev_hazard_hi"
OpName %303 "has_exclusive_access"
OpName %318 "lock_mask"
OpName %321 "prev_lock"
OpName %334 "lock_mask"
OpName %337 "prev_lock"
OpName %351 "lock_mask"
OpName %354 "prev_lock"
OpName %368 "lock_mask"
OpName %371 "prev_lock"
OpName %385 "lock_mask"
OpName %388 "prev_lock"
OpName %399 "lock_mask"
OpName %402 "prev_lock"
OpName %415 "lock_mask"
OpName %418 "prev_lock"
OpName %432 "lock_mask"
OpName %435 "prev_lock"
OpName %438 "has_complete_self_lock"
OpName %454 "hazard"
OpName %490 "ShouldReportInstrumentation"
OpName %493 "InstrumentationControlDataSSBO"
OpMemberName %493 0 "atomics"
OpName %495 "InstrumentationControlData"
OpName %497 "InstrumentationDataSSBO"
OpMemberName %497 0 "data"
OpName %499 "InstrumentationData"
OpName %503 "AssumeTrue"
OpName %501 "value"
OpName %502 "inst"
OpDecorate %6 Block
OpMemberDecorate %6 0 Offset 0
OpMemberDecorate %6 1 Offset 4
OpMemberDecorate %6 2 Offset 8
OpMemberDecorate %6 3 Offset 12
OpMemberDecorate %6 4 Offset 16
OpMemberDecorate %6 5 Offset 20
OpMemberDecorate %6 6 Offset 24
OpMemberDecorate %6 7 Offset 28
OpDecorate %11 ArrayStride 8
OpMemberDecorate %12 0 Offset 0
OpDecorate %13 ArrayStride 8
OpDecorate %14 Block
OpMemberDecorate %14 0 Offset 0
OpDecorate %16 DescriptorSet 0
OpDecorate %16 Binding 0
OpDecorate %20 ArrayStride 12
OpMemberDecorate %21 0 Offset 0
OpDecorate %21 Block
OpDecorate %24 DescriptorSet 1
OpDecorate %24 Binding 0
OpDecorate %24 NonWritable
OpDecorate %24 Restrict
OpDecorate %25 ArrayStride 4
OpMemberDecorate %26 0 Offset 0
OpDecorate %26 Block
OpDecorate %29 DescriptorSet 4
OpDecorate %29 Binding 0
OpDecorate %30 ArrayStride 4
OpMemberDecorate %31 0 Offset 0
OpDecorate %31 Block
OpDecorate %33 DescriptorSet 0
OpDecorate %33 Binding 2
OpDecorate %72 BuiltIn GlobalInvocationId
OpDecorate %120 ArrayStride 8
OpMemberDecorate %121 0 Offset 0
OpDecorate %121 Block
OpDecorate %123 DescriptorSet 0
OpDecorate %123 Binding 2
OpDecorate %124 ArrayStride 8
OpMemberDecorate %125 0 Offset 0
OpDecorate %125 Block
OpDecorate %127 DescriptorSet 0
OpDecorate %127 Binding 2
OpDecorate %492 ArrayStride 4
OpMemberDecorate %493 0 Offset 0
OpDecorate %493 Block
OpDecorate %495 DescriptorSet 0
OpDecorate %495 Binding 2
OpDecorate %496 ArrayStride 16
OpMemberDecorate %497 0 Offset 0
OpDecorate %497 Block
OpDecorate %499 DescriptorSet 0
OpDecorate %499 Binding 3
%1 = OpTypeVoid
%2 = OpTypeFunction %1
%5 = OpTypeInt 32 0
%6 = OpTypeStruct %5 %5 %5 %5 %5 %5 %5 %5
%7 = OpTypePointer PushConstant %6
%8 = OpVariable %7 PushConstant
%9 = OpTypeVector %5 2
%10 = OpConstant %5 1
%11 = OpTypeArray %9 %10
%12 = OpTypeStruct %11
%13 = OpTypeRuntimeArray %12
%14 = OpTypeStruct %13
%15 = OpTypePointer StorageBuffer %14
%16 = OpVariable %15 StorageBuffer
%17 = OpTypePointer Private %5
%18 = OpVariable %17 Private
%19 = OpTypeVector %5 3
%20 = OpTypeRuntimeArray %19
%21 = OpTypeStruct %20
%22 = OpTypeRuntimeArray %21
%23 = OpTypePointer StorageBuffer %22
%24 = OpVariable %23 StorageBuffer
%25 = OpTypeRuntimeArray %5
%26 = OpTypeStruct %25
%27 = OpTypeRuntimeArray %26
%28 = OpTypePointer StorageBuffer %27
%29 = OpVariable %28 StorageBuffer
%30 = OpTypeRuntimeArray %5
%31 = OpTypeStruct %30
%32 = OpTypePointer StorageBuffer %31
%33 = OpVariable %32 StorageBuffer
%34 = OpTypeFunction %5
%39 = OpTypePointer StorageBuffer %5
%41 = OpConstant %5 0
%43 = OpConstant %5 1103633207
%46 = OpTypePointer StorageBuffer %26
%48 = OpTypePointer PushConstant %5
%50 = OpConstant %5 4
%52 = OpTypePointer StorageBuffer %9
%57 = OpConstant %5 16
%60 = OpTypePointer StorageBuffer %21
%70 = OpConstant %5 12
%71 = OpTypePointer Input %19
%72 = OpVariable %71 Input
%73 = OpTypePointer Input %5
%78 = OpTypeFunction %5 %9 %5
%89 = OpConstant %5 65535
%90 = OpConstant %5 8
%91 = OpConstantComposite %9 %90 %90
%118 = OpTypeInt 64 0
%119 = OpTypeBool
%120 = OpTypeRuntimeArray %118
%121 = OpTypeStruct %120
%122 = OpTypePointer StorageBuffer %121
%123 = OpVariable %122 StorageBuffer
%124 = OpTypeRuntimeArray %9
%125 = OpTypeStruct %124
%126 = OpTypePointer StorageBuffer %125
%127 = OpVariable %126 StorageBuffer
%128 = OpTypeFunction %119 %9 %5 %5 %5 %5 %119
%139 = OpConstantTrue %119
%143 = OpTypeStruct %5 %5
%154 = OpConstant %5 4294967295
%155 = OpConstant %5 15
%164 = OpConstant %5 3
%165 = OpConstant %5 2
%175 = OpConstant %5 1103515245
%179 = OpConstant %5 1103518333
%183 = OpConstant %5 1103539331
%190 = OpConstant %5 10006121
%194 = OpConstant %5 4004951
%198 = OpConstant %5 5005159
%202 = OpConstant %5 6004811
%206 = OpConstant %5 383
%210 = OpConstant %5 821
%214 = OpConstant %5 661
%218 = OpConstant %5 1091
%222 = OpConstant %5 1117
%226 = OpConstant %5 3947
%230 = OpConstant %5 4253
%234 = OpConstant %5 7691
%237 = OpTypeVector %118 4
%238 = OpConstant %118 68719411200
%239 = OpConstant %118 1099511627775
%240 = OpConstant %118 1035087118335
%241 = OpConstantComposite %237 %238 %239 %240 %238
%250 = OpTypePointer StorageBuffer %118
%305 = OpTypeInt 32 1
%306 = OpConstant %305 0
%307 = OpConstant %305 3
%309 = OpConstant %5 256
%312 = OpConstant %5 65536
%315 = OpConstant %305 6
%317 = OpConstant %5 16777216
%325 = OpConstant %305 9
%328 = OpConstant %305 12
%332 = OpConstant %305 15
%342 = OpConstant %305 18
%345 = OpConstant %305 21
%349 = OpConstant %305 24
%359 = OpConstant %305 23
%362 = OpConstant %305 26
%366 = OpConstant %305 29
%376 = OpConstant %305 1
%379 = OpConstant %305 4
%383 = OpConstant %305 7
%407 = OpConstant %305 17
%410 = OpConstant %305 20
%423 = OpConstant %305 22
%426 = OpConstant %305 25
%430 = OpConstant %305 28
%461 = OpTypePointer StorageBuffer %19
%464 = OpTypeFloat 32
%465 = OpTypeVector %464 3
%470 = OpConstant %464 40
%489 = OpTypePointer Private %119
%490 = OpVariable %489 Private %139
%491 = OpTypeVector %5 4
%492 = OpTypeRuntimeArray %5
%493 = OpTypeStruct %492
%494 = OpTypePointer StorageBuffer %493
%495 = OpVariable %494 StorageBuffer
%496 = OpTypeRuntimeArray %491
%497 = OpTypeStruct %496
%498 = OpTypePointer StorageBuffer %497
%499 = OpVariable %498 StorageBuffer
%500 = OpTypeFunction %1 %119 %5
%514 = OpConstant %5 97
%515 = OpConstant %5 43981
%521 = OpConstant %5 51329
%533 = OpConstantFalse %119
%536 = OpTypePointer StorageBuffer %491
%539 = OpConstant %5 72
%3 = OpFunction %1 None %2
%4 = OpLabel
OpBranch %488
%488 = OpLabel
%45 = OpFunctionCall %5 %35
OpStore %18 %45
%49 = OpAccessChain %48 %8 %50
%51 = OpLoad %5 %49
%53 = OpAccessChain %52 %16 %41 %51 %41 %41
%54 = OpLoad %9 %53
%55 = OpCompositeExtract %5 %54 1
%56 = OpShiftRightLogical %5 %55 %57
%47 = OpAccessChain %46 %29 %51
%58 = OpArrayLength %5 %47 0
%59 = OpIMul %5 %58 %50
%62 = OpAccessChain %48 %8 %10
%63 = OpLoad %5 %62
%64 = OpAccessChain %52 %16 %41 %63 %41 %41
%65 = OpLoad %9 %64
%66 = OpCompositeExtract %5 %65 1
%67 = OpShiftRightLogical %5 %66 %57
%61 = OpAccessChain %60 %24 %63
%68 = OpArrayLength %5 %61 0
%69 = OpIMul %5 %68 %70
%74 = OpAccessChain %73 %72 %41
%75 = OpLoad %5 %74
%76 = OpIMul %5 %75 %70
%77 = OpIAdd %5 %76 %41
%459 = OpLoad %5 %18
%460 = OpULessThan %119 %77 %69
%458 = OpFunctionCall %119 %135 %65 %77 %70 %41 %459 %460
%541 = OpFunctionCall %1 %503 %458 %10
%462 = OpAccessChain %461 %61 %41 %75
%463 = OpLoad %19 %462
%466 = OpBitcast %465 %463
%467 = OpCompositeExtract %464 %466 0
%468 = OpCompositeExtract %464 %466 2
%469 = OpFAdd %464 %467 %470
%471 = OpFAdd %464 %469 %468
%472 = OpIMul %5 %75 %50
%473 = OpIAdd %5 %472 %41
%475 = OpLoad %5 %18
%476 = OpULessThan %119 %473 %59
%474 = OpFunctionCall %119 %135 %54 %473 %50 %41 %475 %476
%542 = OpFunctionCall %1 %503 %474 %165
%477 = OpAccessChain %39 %47 %41 %75
%478 = OpLoad %5 %477
%479 = OpBitcast %464 %478
%480 = OpFAdd %464 %471 %479
%481 = OpIMul %5 %75 %50
%482 = OpIAdd %5 %481 %41
%484 = OpLoad %5 %18
%485 = OpULessThan %119 %482 %59
%483 = OpFunctionCall %119 %135 %54 %482 %50 %10 %484 %485
%543 = OpFunctionCall %1 %503 %483 %164
%486 = OpBitcast %5 %480
%487 = OpAccessChain %39 %47 %41 %75
OpStore %487 %486
OpReturn
OpFunctionEnd
%35 = OpFunction %5 None %34
%36 = OpLabel
%37 = OpArrayLength %5 %33 0
%38 = OpISub %5 %37 %10
%40 = OpAccessChain %39 %33 %41 %38
%42 = OpAtomicIAdd %5 %40 %10 %41 %43
OpReturnValue %42
OpFunctionEnd
%81 = OpFunction %5 None %78
%79 = OpFunctionParameter %9
%80 = OpFunctionParameter %5
%82 = OpLabel
%83 = OpCompositeExtract %5 %79 0
%84 = OpCompositeExtract %5 %79 1
%85 = OpShiftRightLogical %5 %83 %50
%86 = OpBitwiseAnd %5 %84 %89
%87 = OpCompositeConstruct %9 %85 %86
%88 = OpCompositeConstruct %9 %80 %80
%92 = OpVectorShuffle %9 %87 %87 1 0
%93 = OpShiftRightLogical %9 %87 %91
%94 = OpBitwiseXor %9 %93 %92
%95 = OpIMul %9 %94 %88
%96 = OpVectorShuffle %9 %95 %95 1 0
%97 = OpShiftRightLogical %9 %95 %91
%98 = OpBitwiseXor %9 %97 %96
%99 = OpIMul %9 %98 %88
%100 = OpVectorShuffle %9 %99 %99 1 0
%101 = OpShiftRightLogical %9 %99 %91
%102 = OpBitwiseXor %9 %101 %100
%103 = OpIMul %9 %102 %88
%104 = OpVectorShuffle %9 %103 %103 1 0
%105 = OpShiftRightLogical %9 %103 %91
%106 = OpBitwiseXor %9 %105 %104
%107 = OpIMul %9 %106 %88
%108 = OpVectorShuffle %9 %107 %107 1 0
%109 = OpShiftRightLogical %9 %107 %91
%110 = OpBitwiseXor %9 %109 %108
%111 = OpIMul %9 %110 %88
%112 = OpVectorShuffle %9 %111 %111 1 0
%113 = OpShiftRightLogical %9 %111 %91
%114 = OpBitwiseXor %9 %113 %112
%115 = OpIMul %9 %114 %88
%116 = OpCompositeExtract %5 %115 0
OpReturnValue %116
OpFunctionEnd
%135 = OpFunction %119 None %128
%129 = OpFunctionParameter %9
%130 = OpFunctionParameter %5
%131 = OpFunctionParameter %5
%132 = OpFunctionParameter %5
%133 = OpFunctionParameter %5
%134 = OpFunctionParameter %119
%136 = OpLabel
OpSelectionMerge %138 None
OpBranchConditional %134 %138 %137
%137 = OpLabel
OpReturnValue %139
%138 = OpLabel
%141 = OpCompositeExtract %5 %129 0
%142 = OpCompositeExtract %5 %129 1
%144 = OpIAddCarry %143 %141 %130
%145 = OpCompositeExtract %5 %144 0
%146 = OpCompositeExtract %5 %144 1
%147 = OpIAdd %5 %142 %146
%148 = OpCompositeConstruct %9 %145 %147
%149 = OpCompositeExtract %5 %148 0
%150 = OpBitFieldUExtract %5 %154 %41 %131
%151 = OpBitwiseAnd %5 %149 %155
%152 = OpShiftLeftLogical %5 %150 %151
%153 = OpBitwiseAnd %5 %152 %89
%156 = OpBitwiseAnd %5 %149 %164
%157 = OpIAdd %5 %156 %131
%158 = OpIAdd %5 %157 %164
%159 = OpShiftRightLogical %5 %158 %165
%160 = OpBitFieldUExtract %5 %149 %165 %165
%161 = OpBitFieldUExtract %5 %154 %41 %159
%162 = OpShiftLeftLogical %5 %161 %160
%163 = OpBitwiseAnd %5 %162 %155
%166 = OpArrayLength %5 %123 0
%167 = OpExtInst %5 %169 FindUMsb %166
%168 = OpBitFieldUExtract %5 %154 %41 %167
%170 = OpArrayLength %5 %123 0
%171 = OpExtInst %5 %169 FindUMsb %170
%172 = OpBitFieldUExtract %5 %170 %41 %171
%173 = OpISub %5 %172 %10
%174 = OpFunctionCall %5 %81 %148 %175
%176 = OpBitwiseAnd %5 %174 %168
%177 = OpIAdd %5 %176 %173
%178 = OpFunctionCall %5 %81 %148 %179
%180 = OpBitwiseAnd %5 %178 %168
%181 = OpIAdd %5 %180 %173
%182 = OpFunctionCall %5 %81 %148 %183
%184 = OpBitwiseAnd %5 %182 %168
%185 = OpIAdd %5 %184 %173
%186 = OpFunctionCall %5 %81 %148 %43
%187 = OpBitwiseAnd %5 %186 %168
%188 = OpIAdd %5 %187 %173
%189 = OpFunctionCall %5 %81 %148 %190
%191 = OpBitwiseAnd %5 %189 %168
%192 = OpIAdd %5 %191 %173
%193 = OpFunctionCall %5 %81 %148 %194
%195 = OpBitwiseAnd %5 %193 %168
%196 = OpIAdd %5 %195 %173
%197 = OpFunctionCall %5 %81 %148 %198
%199 = OpBitwiseAnd %5 %197 %168
%200 = OpIAdd %5 %199 %173
%201 = OpFunctionCall %5 %81 %148 %202
%203 = OpBitwiseAnd %5 %201 %168
%204 = OpIAdd %5 %203 %173
%205 = OpFunctionCall %5 %81 %148 %206
%207 = OpBitwiseAnd %5 %205 %168
%208 = OpIAdd %5 %207 %173
%209 = OpFunctionCall %5 %81 %148 %210
%211 = OpBitwiseAnd %5 %209 %168
%212 = OpIAdd %5 %211 %173
%213 = OpFunctionCall %5 %81 %148 %214
%215 = OpBitwiseAnd %5 %213 %168
%216 = OpIAdd %5 %215 %173
%217 = OpFunctionCall %5 %81 %148 %218
%219 = OpBitwiseAnd %5 %217 %168
%220 = OpIAdd %5 %219 %173
%221 = OpFunctionCall %5 %81 %148 %222
%223 = OpBitwiseAnd %5 %221 %168
%224 = OpIAdd %5 %223 %173
%225 = OpFunctionCall %5 %81 %148 %226
%227 = OpBitwiseAnd %5 %225 %168
%228 = OpIAdd %5 %227 %173
%229 = OpFunctionCall %5 %81 %148 %230
%231 = OpBitwiseAnd %5 %229 %168
%232 = OpIAdd %5 %231 %173
%233 = OpFunctionCall %5 %81 %148 %234
%235 = OpBitwiseAnd %5 %233 %168
%236 = OpIAdd %5 %235 %173
%242 = OpVectorExtractDynamic %118 %241 %132
%243 = OpShiftLeftLogical %5 %153 %57
%244 = OpShiftLeftLogical %5 %163 %50
%245 = OpBitwiseOr %5 %153 %243
%246 = OpBitwiseOr %5 %163 %244
%247 = OpCompositeConstruct %9 %245 %246
%248 = OpBitcast %118 %247
%249 = OpBitwiseAnd %118 %242 %248
%251 = OpInBoundsAccessChain %250 %123 %41 %177
%252 = OpAtomicOr %118 %251 %10 %41 %249
%253 = OpInBoundsAccessChain %250 %123 %41 %181
%254 = OpAtomicOr %118 %253 %10 %41 %249
%255 = OpBitwiseAnd %118 %252 %254
%256 = OpInBoundsAccessChain %250 %123 %41 %185
%257 = OpAtomicOr %118 %256 %10 %41 %249
%258 = OpBitwiseAnd %118 %255 %257
%259 = OpInBoundsAccessChain %250 %123 %41 %188
%260 = OpAtomicOr %118 %259 %10 %41 %249
%261 = OpBitwiseAnd %118 %258 %260
%262 = OpInBoundsAccessChain %250 %123 %41 %192
%263 = OpAtomicOr %118 %262 %10 %41 %249
%264 = OpBitwiseAnd %118 %261 %263
%265 = OpInBoundsAccessChain %250 %123 %41 %196
%266 = OpAtomicOr %118 %265 %10 %41 %249
%267 = OpBitwiseAnd %118 %264 %266
%268 = OpInBoundsAccessChain %250 %123 %41 %200
%269 = OpAtomicOr %118 %268 %10 %41 %249
%270 = OpBitwiseAnd %118 %267 %269
%271 = OpInBoundsAccessChain %250 %123 %41 %204
%272 = OpAtomicOr %118 %271 %10 %41 %249
%273 = OpBitwiseAnd %118 %270 %272
%274 = OpInBoundsAccessChain %250 %123 %41 %208
%275 = OpAtomicOr %118 %274 %10 %41 %249
%276 = OpBitwiseAnd %118 %273 %275
%277 = OpInBoundsAccessChain %250 %123 %41 %212
%278 = OpAtomicOr %118 %277 %10 %41 %249
%279 = OpBitwiseAnd %118 %276 %278
%280 = OpInBoundsAccessChain %250 %123 %41 %216
%281 = OpAtomicOr %118 %280 %10 %41 %249
%282 = OpBitwiseAnd %118 %279 %281
%283 = OpInBoundsAccessChain %250 %123 %41 %220
%284 = OpAtomicOr %118 %283 %10 %41 %249
%285 = OpBitwiseAnd %118 %282 %284
%286 = OpInBoundsAccessChain %250 %123 %41 %224
%287 = OpAtomicOr %118 %286 %10 %41 %249
%288 = OpBitwiseAnd %118 %285 %287
%289 = OpInBoundsAccessChain %250 %123 %41 %228
%290 = OpAtomicOr %118 %289 %10 %41 %249
%291 = OpBitwiseAnd %118 %288 %290
%292 = OpInBoundsAccessChain %250 %123 %41 %232
%293 = OpAtomicOr %118 %292 %10 %41 %249
%294 = OpBitwiseAnd %118 %291 %293
%295 = OpInBoundsAccessChain %250 %123 %41 %236
%296 = OpAtomicOr %118 %295 %10 %41 %249
%297 = OpBitwiseAnd %118 %294 %296
%298 = OpBitcast %9 %297
%299 = OpCompositeExtract %5 %298 0
%300 = OpCompositeExtract %5 %298 1
%301 = OpShiftRightLogical %5 %299 %57
%302 = OpBitwiseAnd %5 %301 %153
%303 = OpIEqual %119 %302 %41
%304 = OpBitFieldUExtract %5 %133 %306 %307
%308 = OpShiftLeftLogical %5 %309 %304
%310 = OpBitFieldUExtract %5 %133 %307 %307
%311 = OpShiftLeftLogical %5 %312 %310
%313 = OpBitwiseOr %5 %308 %311
%314 = OpBitFieldUExtract %5 %133 %315 %307
%316 = OpShiftLeftLogical %5 %317 %314
%318 = OpBitwiseOr %5 %313 %316
%319 = OpSelect %5 %303 %318 %41
%320 = OpInBoundsAccessChain %39 %127 %41 %177 %10
%321 = OpAtomicOr %5 %320 %10 %41 %319
%322 = OpBitwiseAnd %5 %321 %318
%323 = OpIEqual %119 %322 %318
%324 = OpBitFieldUExtract %5 %133 %325 %307
%326 = OpShiftLeftLogical %5 %309 %324
%327 = OpBitFieldUExtract %5 %133 %328 %307
%329 = OpShiftLeftLogical %5 %312 %327
%330 = OpBitwiseOr %5 %326 %329
%331 = OpBitFieldUExtract %5 %133 %332 %307
%333 = OpShiftLeftLogical %5 %317 %331
%334 = OpBitwiseOr %5 %330 %333
%335 = OpSelect %5 %303 %334 %41
%336 = OpInBoundsAccessChain %39 %127 %41 %181 %10
%337 = OpAtomicOr %5 %336 %10 %41 %335
%338 = OpBitwiseAnd %5 %337 %334
%339 = OpIEqual %119 %338 %334
%340 = OpLogicalAnd %119 %323 %339
%341 = OpBitFieldUExtract %5 %133 %342 %307
%343 = OpShiftLeftLogical %5 %309 %341
%344 = OpBitFieldUExtract %5 %133 %345 %307
%346 = OpShiftLeftLogical %5 %312 %344
%347 = OpBitwiseOr %5 %343 %346
%348 = OpBitFieldUExtract %5 %133 %349 %307
%350 = OpShiftLeftLogical %5 %317 %348
%351 = OpBitwiseOr %5 %347 %350
%352 = OpSelect %5 %303 %351 %41
%353 = OpInBoundsAccessChain %39 %127 %41 %185 %10
%354 = OpAtomicOr %5 %353 %10 %41 %352
%355 = OpBitwiseAnd %5 %354 %351
%356 = OpIEqual %119 %355 %351
%357 = OpLogicalAnd %119 %340 %356
%358 = OpBitFieldUExtract %5 %133 %359 %307
%360 = OpShiftLeftLogical %5 %309 %358
%361 = OpBitFieldUExtract %5 %133 %362 %307
%363 = OpShiftLeftLogical %5 %312 %361
%364 = OpBitwiseOr %5 %360 %363
%365 = OpBitFieldUExtract %5 %133 %366 %307
%367 = OpShiftLeftLogical %5 %317 %365
%368 = OpBitwiseOr %5 %364 %367
%369 = OpSelect %5 %303 %368 %41
%370 = OpInBoundsAccessChain %39 %127 %41 %188 %10
%371 = OpAtomicOr %5 %370 %10 %41 %369
%372 = OpBitwiseAnd %5 %371 %368
%373 = OpIEqual %119 %372 %368
%374 = OpLogicalAnd %119 %357 %373
%375 = OpBitFieldUExtract %5 %133 %376 %307
%377 = OpShiftLeftLogical %5 %309 %375
%378 = OpBitFieldUExtract %5 %133 %379 %307
%380 = OpShiftLeftLogical %5 %312 %378
%381 = OpBitwiseOr %5 %377 %380
%382 = OpBitFieldUExtract %5 %133 %383 %307
%384 = OpShiftLeftLogical %5 %317 %382
%385 = OpBitwiseOr %5 %381 %384
%386 = OpSelect %5 %303 %385 %41
%387 = OpInBoundsAccessChain %39 %127 %41 %192 %10
%388 = OpAtomicOr %5 %387 %10 %41 %386
%389 = OpBitwiseAnd %5 %388 %385
%390 = OpIEqual %119 %389 %385
%391 = OpLogicalAnd %119 %374 %390
%392 = OpBitFieldUExtract %5 %133 %325 %307
%393 = OpShiftLeftLogical %5 %309 %392
%394 = OpBitFieldUExtract %5 %133 %328 %307
%395 = OpShiftLeftLogical %5 %312 %394
%396 = OpBitwiseOr %5 %393 %395
%397 = OpBitFieldUExtract %5 %133 %332 %307
%398 = OpShiftLeftLogical %5 %317 %397
%399 = OpBitwiseOr %5 %396 %398
%400 = OpSelect %5 %303 %399 %41
%401 = OpInBoundsAccessChain %39 %127 %41 %196 %10
%402 = OpAtomicOr %5 %401 %10 %41 %400
%403 = OpBitwiseAnd %5 %402 %399
%404 = OpIEqual %119 %403 %399
%405 = OpLogicalAnd %119 %391 %404
%406 = OpBitFieldUExtract %5 %133 %407 %307
%408 = OpShiftLeftLogical %5 %309 %406
%409 = OpBitFieldUExtract %5 %133 %410 %307
%411 = OpShiftLeftLogical %5 %312 %409
%412 = OpBitwiseOr %5 %408 %411
%413 = OpBitFieldUExtract %5 %133 %359 %307
%414 = OpShiftLeftLogical %5 %317 %413
%415 = OpBitwiseOr %5 %412 %414
%416 = OpSelect %5 %303 %415 %41
%417 = OpInBoundsAccessChain %39 %127 %41 %200 %10
%418 = OpAtomicOr %5 %417 %10 %41 %416
%419 = OpBitwiseAnd %5 %418 %415
%420 = OpIEqual %119 %419 %415
%421 = OpLogicalAnd %119 %405 %420
%422 = OpBitFieldUExtract %5 %133 %423 %307
%424 = OpShiftLeftLogical %5 %309 %422
%425 = OpBitFieldUExtract %5 %133 %426 %307
%427 = OpShiftLeftLogical %5 %312 %425
%428 = OpBitwiseOr %5 %424 %427
%429 = OpBitFieldUExtract %5 %133 %430 %307
%431 = OpShiftLeftLogical %5 %317 %429
%432 = OpBitwiseOr %5 %428 %431
%433 = OpSelect %5 %303 %432 %41
%434 = OpInBoundsAccessChain %39 %127 %41 %204 %10
%435 = OpAtomicOr %5 %434 %10 %41 %433
%436 = OpBitwiseAnd %5 %435 %432
%437 = OpIEqual %119 %436 %432
%438 = OpLogicalAnd %119 %421 %437
OpSelectionMerge %443 None
OpSwitch %132 %442 0 %439 1 %440 2 %441
%442 = OpLabel
%451 = OpShiftLeftLogical %5 %163 %50
%452 = OpBitwiseAnd %5 %300 %451
%453 = OpINotEqual %119 %452 %41
OpBranch %443
%439 = OpLabel
%444 = OpBitwiseAnd %5 %299 %153
%445 = OpINotEqual %119 %444 %41
OpBranch %443
%440 = OpLabel
%446 = OpShiftLeftLogical %5 %153 %57
%447 = OpBitwiseAnd %5 %299 %446
%448 = OpINotEqual %119 %447 %41
OpBranch %443
%441 = OpLabel
%449 = OpBitwiseAnd %5 %300 %163
%450 = OpINotEqual %119 %449 %41
OpBranch %443
%443 = OpLabel
%454 = OpPhi %119 %445 %439 %448 %440 %450 %441 %453 %442
%455 = OpLogicalNot %119 %454
%456 = OpLogicalOr %119 %455 %438
OpReturnValue %456
OpFunctionEnd
%503 = OpFunction %1 None %500
%501 = OpFunctionParameter %119
%502 = OpFunctionParameter %5
%504 = OpLabel
%507 = OpLogicalNot %119 %501
%508 = OpLoad %119 %490
%509 = OpLogicalAnd %119 %507 %508
OpSelectionMerge %505 None
OpBranchConditional %509 %506 %505
%506 = OpLabel
%512 = OpIMul %5 %502 %514
%513 = OpBitwiseXor %5 %512 %515
%516 = OpArrayLength %5 %495 0
%517 = OpISub %5 %516 %165
%518 = OpAccessChain %39 %495 %41 %517
%519 = OpLoad %5 %518
%520 = OpIMul %5 %519 %521
%522 = OpBitwiseXor %5 %513 %520
%523 = OpArrayLength %5 %499 0
%524 = OpISub %5 %523 %10
%525 = OpBitwiseAnd %5 %522 %524
%526 = OpShiftRightLogical %5 %525 %50
%527 = OpBitwiseAnd %5 %525 %155
%528 = OpShiftLeftLogical %5 %10 %527
%529 = OpAccessChain %39 %495 %41 %526
%530 = OpAtomicOr %5 %529 %10 %41 %528
%531 = OpBitwiseAnd %5 %530 %528
%532 = OpIEqual %119 %531 %41
OpStore %490 %533
OpSelectionMerge %511 None
OpBranchConditional %532 %510 %511
%510 = OpLabel
%534 = OpCompositeConstruct %491 %515 %41 %502 %519
%535 = OpShiftLeftLogical %5 %528 %57
%537 = OpAccessChain %536 %499 %41 %525
OpStore %537 %534
OpMemoryBarrier %10 %539
%538 = OpAtomicOr %5 %529 %10 %41 %535
OpMemoryBarrier %10 %539
OpBranch %511
%511 = OpLabel
OpBranch %505
%505 = OpLabel
OpReturn
OpFunctionEnd
#endif
