While loop

    // Traversal (use for for testing)
    while (node_id != 0xFFFFFFFF)
    {
        BVHNode n = ASTreeData[node_id];

        temp.x += 0.1f;

        [branch] if (n.PrimitiveCount == 0)
        {
            // Fetch children bounding boxes
            float4 n0xy = n.LXY;
            float4 n1xy = n.RXY;
            float4 nz = n.LRZ;

            // Test against child AABBs
            float c0lox = n0xy.x * inv.x - oinv.x;
            float c0hix = n0xy.y * inv.x - oinv.x;
            float c0loy = n0xy.z * inv.y - oinv.y;
            float c0hiy = n0xy.w * inv.y - oinv.y;
            float c0loz = nz.x * inv.z - oinv.z;
            float c0hiz = nz.y * inv.z - oinv.z;
            float c1loz = nz.z * inv.z - oinv.z;
            float c1hiz = nz.w * inv.z - oinv.z;
            float c0min = max(max(min(c0lox, c0hix), min(c0loy, c0hiy)), max(min(c0loz, c0hiz), tmin));
            float c0max = min(min(max(c0lox, c0hix), max(c0loy, c0hiy)), min(max(c0loz, c0hiz), tmax));
            float c1lox = n1xy.x * inv.x - oinv.x;
            float c1hix = n1xy.y * inv.x - oinv.x;
            float c1loy = n1xy.z * inv.y - oinv.y;
            float c1hiy = n1xy.w * inv.y - oinv.y;
            float c1min = max(max(min(c1lox, c1hix), min(c1loy, c1hiy)), max(min(c1loz, c1hiz), tmin));
            float c1max = min(min(max(c1lox, c1hix), max(c1loy, c1hiy)), min(max(c1loz, c1hiz), tmax));

            bool traverseChild0 = (c0max >= c0min);
            bool traverseChild1 = (c1max >= c1min);

            // If no children was hit, get node from stack
            if (!traverseChild0 && !traverseChild1)
            {
                if (stack_ptr == meshbvh_stack_ptr)
                {
                    meshbvh_stack_ptr = -1;
                    o = r.Origin;
                    d = r.Direction;
                    inv = r.Inverse;
                    oinv = o * inv;
                }

                node_id = stack[stack_ptr];
                stack_ptr--;
            }
            else if (traverseChild0 || traverseChild1)
            {
                uint first_child = node_id + 1;
                uint second_child = n.PrimitiveOffset;
                node_id = (traverseChild0) ? first_child : second_child;

                if (traverseChild0 && traverseChild1)
                {
                    if (c1min < c0min)
                    {
                        node_id = second_child;
                        stack_ptr++;
                        stack[stack_ptr] = first_child;
                    }
                    else
                    {
                        stack_ptr++;
                        stack[stack_ptr] = second_child;
                    }
                }
            }
        }
        else if (n.PrimitiveCount == -1)
        {
            meshbvh_stack_ptr = stack_ptr;

            uint blas_offset = n.PrimitiveOffset;
            uint instance_index = ASIndexData[blas_offset];
            instance = Instances[instance_index];

            node_id = ASTreeNodes[Geometries[instance.GeometryNode].BVHNode + 1].Offset / 64;

            o = mul(r.Origin, instance.TransformInverse);
            d = mul(r.Direction, instance.TransformInverse);
            inv = rcp(d);
            oinv = o * inv;
        }
        else
        {
            if (n.PrimitiveCount > 0)
            {
                GeometryNode geom = Geometries[instance.GeometryNode];
                //MemoryNode vbo = VertexNodes[geom.VertexBufferNode];
                //MemoryNode ibo = IndexNodes[geom.IndexBufferNode];
                MemoryNode wbo = WoopNodes[geom.WoopBufferNode];

                uint index_offset = ASIndexNodes[n.PrimitiveOffset].Offset / 4;

                for (uint j = 0; j < n.PrimitiveCount; j++)
                {
                    // Don't trash cache by reading index through it
                    uint tri_idx = ASIndexData[n.PrimitiveOffset + j] * 3;
                    float4 r = WoopData[wbo.Offset / 16 + tri_idx + 0];
                    float4 p = WoopData[wbo.Offset / 16 + tri_idx + 1];
                    float4 q = WoopData[wbo.Offset / 16 + tri_idx + 2];

                    float o_z = r.w - o.x * r.x - o.y * r.y - o.z * r.z;
                    float i_z = 1.0f / (d.x * r.x + d.y * r.y + d.z * r.z);
                    float t = o_z * i_z;

                    if (t > tmin && t < tmax)
                    {
                        float o_x = p.w + o.x * p.x + o.y * p.y + o.z * p.z;
                        float d_x = d.x * p.x + d.y * p.y + d.z * p.z;
                        float u = o_x + t * d_x;

                        if (u >= 0.0f && u <= 1.0f)
                        {
                            float o_y = q.w + o.x * q.x + o.y * q.y + o.z * q.z;
                            float d_y = d.x * q.x + d.y * q.y + d.z * q.z;
                            float v = o_y + t * d_y;

                            if (v >= 0.0f && u + v <= 1.0f)
                            {
                                tmax = t;
                                bU = u;
                                bV = v;
                                hit = true;

                                //id = prims_ids[n];
                            }
                        }
                    }
                }
            }

            if (stack_ptr == meshbvh_stack_ptr)
            {
                meshbvh_stack_ptr = -1;
                o = r.Origin;
                d = r.Direction;
                inv = r.Inverse;
                oinv = o * inv;
            }

            node_id = stack[stack_ptr];
            stack_ptr--;
        }
    }