From 242019a2b5e460b00f98ca449b97b8f9c4b35af3 Mon Sep 17 00:00:00 2001 From: Craig Gidney Date: Tue, 23 Jan 2024 22:52:50 -0800 Subject: [PATCH] Add CZSWAP, add specialized pauli string ops --- file_lists/test_files | 1 + src/stim/circuit/circuit.test.cc | 1 + src/stim/circuit/export_qasm.cc | 7 +- src/stim/circuit/export_qasm.test.cc | 4 + src/stim/diagram/diagram_util.cc | 2 + .../timeline/timeline_ascii_drawer.test.cc | 6 +- src/stim/gates/gate_data_swaps.cc | 32 + src/stim/gates/gates.h | 3 +- src/stim/simulators/error_analyzer.cc | 6 + src/stim/simulators/error_analyzer.h | 1 + src/stim/simulators/error_matcher.cc | 2 +- src/stim/simulators/frame_simulator.h | 1 + src/stim/simulators/frame_simulator.inl | 16 +- src/stim/simulators/graph_simulator.cc | 4 +- .../simulators/sparse_rev_frame_tracker.cc | 14 + .../simulators/sparse_rev_frame_tracker.h | 1 + src/stim/simulators/tableau_simulator.h | 1 + src/stim/simulators/tableau_simulator.inl | 15 + src/stim/stabilizers/pauli_string.test.cc | 10 +- src/stim/stabilizers/pauli_string_ref.h | 73 +- src/stim/stabilizers/pauli_string_ref.inl | 1005 +++++++++++++++-- src/stim/stabilizers/pauli_string_ref.test.cc | 78 ++ testdata/circuit_all_ops_3d.gltf | 2 +- testdata/circuit_all_ops_detslice.svg | 5 + testdata/circuit_all_ops_timeline.svg | 5 + testdata/circuit_all_ops_timeslice.svg | 5 + 26 files changed, 1181 insertions(+), 119 deletions(-) create mode 100644 src/stim/stabilizers/pauli_string_ref.test.cc diff --git a/file_lists/test_files b/file_lists/test_files index 4b8d1d6ee..6506e3f6a 100644 --- a/file_lists/test_files +++ b/file_lists/test_files @@ -74,6 +74,7 @@ src/stim/stabilizers/conversions.test.cc src/stim/stabilizers/flex_pauli_string.test.cc src/stim/stabilizers/pauli_string.test.cc src/stim/stabilizers/pauli_string_iter.test.cc +src/stim/stabilizers/pauli_string_ref.test.cc src/stim/stabilizers/tableau.test.cc src/stim/stabilizers/tableau_iter.test.cc src/stim/str_util.test.cc diff --git a/src/stim/circuit/circuit.test.cc b/src/stim/circuit/circuit.test.cc index 6615ae520..0103bf64b 100644 --- a/src/stim/circuit/circuit.test.cc +++ b/src/stim/circuit/circuit.test.cc @@ -1619,6 +1619,7 @@ Circuit stim::generate_test_circuit_with_all_operations() { ISWAP_DAG 4 5 SWAP 6 7 SWAPCX 8 9 + CZSWAP 10 11 SQRT_XX 0 1 SQRT_XX_DAG 2 3 SQRT_YY 4 5 diff --git a/src/stim/circuit/export_qasm.cc b/src/stim/circuit/export_qasm.cc index a5a9ec8da..b966608d7 100644 --- a/src/stim/circuit/export_qasm.cc +++ b/src/stim/circuit/export_qasm.cc @@ -259,7 +259,7 @@ struct QasmExporter { target = t1; break; default: - throw std::invalid_argument("Not implemented: " + instruction.str()); + throw std::invalid_argument("Not implemented in output_two_qubit_unitary_instruction_with_possible_feedback: " + instruction.str()); } out << "if ("; @@ -279,7 +279,7 @@ struct QasmExporter { } out << "sweep[" << control.value() << "]"; } else { - throw std::invalid_argument("Not implemented: " + instruction.str()); + throw std::invalid_argument("Not implemented in output_two_qubit_unitary_instruction_with_possible_feedback: " + instruction.str()); } out << ") {\n"; out << " " << basis << " q[" << target.qubit_value() << "];\n"; @@ -415,6 +415,7 @@ struct QasmExporter { define_custom_single_qubit_gate(GateType::SQRT_Y_DAG, "sydg"); define_custom_decomposed_gate(GateType::CXSWAP, "cxswap"); + define_custom_decomposed_gate(GateType::CZSWAP, "czswap"); define_custom_decomposed_gate(GateType::ISWAP, "iswap"); define_custom_decomposed_gate(GateType::ISWAP_DAG, "iswapdg"); define_custom_decomposed_gate(GateType::SQRT_XX, "sxx"); @@ -557,7 +558,7 @@ struct QasmExporter { } } - throw std::invalid_argument("Not implemented: " + instruction.str()); + throw std::invalid_argument("Not implemented in QasmExporter::output_instruction: " + instruction.str()); } }; diff --git a/src/stim/circuit/export_qasm.test.cc b/src/stim/circuit/export_qasm.test.cc index d8f9d86f4..d0f67e86e 100644 --- a/src/stim/circuit/export_qasm.test.cc +++ b/src/stim/circuit/export_qasm.test.cc @@ -261,6 +261,7 @@ gate hyz q0 { U(pi/2, pi/2, pi/2) q0; } gate sy q0 { U(pi/2, 0, 0) q0; } gate sydg q0 { U(pi/2, pi/2, pi/2) q0; } gate cxswap q0, q1 { cx q1, q0; cx q0, q1; } +gate czswap q0, q1 { h q0; cx q0, q1; cx q1, q0; h q1; } gate iswap q0, q1 { h q0; cx q0, q1; cx q1, q0; h q1; s q1; s q0; } gate iswapdg q0, q1 { s q0; s q0; s q0; s q1; s q1; s q1; h q1; cx q1, q0; cx q0, q1; h q0; } gate sxx q0, q1 { h q0; cx q0, q1; h q1; s q0; s q1; h q0; h q1; } @@ -317,6 +318,7 @@ iswap q[2], q[3]; iswapdg q[4], q[5]; swap q[6], q[7]; swapcx q[8], q[9]; +czswap q[10], q[11]; sxx q[0], q[1]; sxxdg q[2], q[3]; syy q[4], q[5]; @@ -419,6 +421,7 @@ gate hyz q0 { U(pi/2, pi/2, pi/2) q0; } gate sy q0 { U(pi/2, 0, 0) q0; } gate sydg q0 { U(pi/2, pi/2, pi/2) q0; } gate cxswap q0, q1 { cx q1, q0; cx q0, q1; } +gate czswap q0, q1 { h q0; cx q0, q1; cx q1, q0; h q1; } gate iswap q0, q1 { h q0; cx q0, q1; cx q1, q0; h q1; s q1; s q0; } gate iswapdg q0, q1 { s q0; s q0; s q0; s q1; s q1; s q1; h q1; cx q1, q0; cx q0, q1; h q0; } gate sxx q0, q1 { h q0; cx q0, q1; h q1; s q0; s q1; h q0; h q1; } @@ -462,6 +465,7 @@ iswap q[2], q[3]; iswapdg q[4], q[5]; swap q[6], q[7]; swapcx q[8], q[9]; +czswap q[10], q[11]; sxx q[0], q[1]; sxxdg q[2], q[3]; syy q[4], q[5]; diff --git a/src/stim/diagram/diagram_util.cc b/src/stim/diagram/diagram_util.cc index 8fee5212d..56d34851f 100644 --- a/src/stim/diagram/diagram_util.cc +++ b/src/stim/diagram/diagram_util.cc @@ -25,6 +25,8 @@ std::pair stim_draw_internal::two_qubit_gate_pieces(Ga return {"Y", "Z"}; } else if (gate_type == GateType::CXSWAP) { return {"ZSWAP", "XSWAP"}; + } else if (gate_type == GateType::CZSWAP) { + return {"ZSWAP", "ZSWAP"}; } else if (gate_type == GateType::SWAPCX) { return {"XSWAP", "ZSWAP"}; } else { diff --git a/src/stim/diagram/timeline/timeline_ascii_drawer.test.cc b/src/stim/diagram/timeline/timeline_ascii_drawer.test.cc index 54c5b56bc..63dbd63fc 100644 --- a/src/stim/diagram/timeline/timeline_ascii_drawer.test.cc +++ b/src/stim/diagram/timeline/timeline_ascii_drawer.test.cc @@ -535,9 +535,9 @@ TEST(circuit_diagram_timeline_text, test_circuit_all_ops) { | | | | | q9: ----------------------------------------ZSWAP-----SQRT_ZZ-----Y-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------R----------------------|------------|---------------------------------------------------------------------------------------------------------------------------------------------------------- | | -q10: --------------------------------------------------SQRT_ZZ_DAG-Y------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------|---------------------------------------------------------------------------------------------------------------------------------------------------------- - | | | | -q11: --------------------------------------------------SQRT_ZZ_DAG-@------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------|---------------------------------------------------------------------------------------------------------------------------------------------------------- +q10: ----------------------------------------ZSWAP-----SQRT_ZZ_DAG-Y------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------|---------------------------------------------------------------------------------------------------------------------------------------------------------- + | | | | | +q11: ----------------------------------------ZSWAP-----SQRT_ZZ_DAG-@------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------|---------------------------------------------------------------------------------------------------------------------------------------------------------- | | q12: --------------------------------------------------------------@------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------|---------------------------------------------------------------------------------------------------------------------------------------------------------- | | | diff --git a/src/stim/gates/gate_data_swaps.cc b/src/stim/gates/gate_data_swaps.cc index 62cbcc29e..5a47a811a 100644 --- a/src/stim/gates/gate_data_swaps.cc +++ b/src/stim/gates/gate_data_swaps.cc @@ -175,4 +175,36 @@ CNOT 0 1 CNOT 1 0 )CIRCUIT", }); + + add_gate( + failed, + Gate{ + .name = "CZSWAP", + .id = GateType::CZSWAP, + .best_candidate_inverse_id = GateType::CZSWAP, + .arg_count = 0, + .flags = (GateFlags)(GATE_IS_UNITARY | GATE_TARGETS_PAIRS), + .category = "C_Two Qubit Clifford Gates", + .help = R"MARKDOWN( +A combination CZ-and-SWAP gate. +This gate is kak-equivalent to the iswap gate. + +Parens Arguments: + + This instruction takes no parens arguments. + +Targets: + + Qubit pairs to operate on. +)MARKDOWN", + .unitary_data = {{1, 0, 0, 0}, {0, 0, 1, 0}, {0, 1, 0, 0}, {0, 0, 0, -1}}, + .flow_data = {"+ZX", "+IZ", "+XZ", "+ZI"}, + .h_s_cx_m_r_decomposition = R"CIRCUIT( +H 0 +CX 0 1 +CX 1 0 +H 1 +)CIRCUIT", + }); + add_gate_alias(failed, "SWAPCZ", "CZSWAP"); } diff --git a/src/stim/gates/gates.h b/src/stim/gates/gates.h index 9fec1e9c6..f6f9c577f 100644 --- a/src/stim/gates/gates.h +++ b/src/stim/gates/gates.h @@ -76,7 +76,7 @@ constexpr inline uint16_t gate_name_to_hash(const char *c) { return gate_name_to_hash(c, std::char_traits::length(c)); } -constexpr const size_t NUM_DEFINED_GATES = 67; +constexpr const size_t NUM_DEFINED_GATES = 68; enum class GateType : uint8_t { NOT_A_GATE = 0, @@ -154,6 +154,7 @@ enum class GateType : uint8_t { ISWAP, CXSWAP, SWAPCX, + CZSWAP, ISWAP_DAG, // Pair measurement gates MXX, diff --git a/src/stim/simulators/error_analyzer.cc b/src/stim/simulators/error_analyzer.cc index 06fd2cb35..9f8e5245c 100644 --- a/src/stim/simulators/error_analyzer.cc +++ b/src/stim/simulators/error_analyzer.cc @@ -221,6 +221,9 @@ void ErrorAnalyzer::undo_gate(const CircuitInstruction &inst) { case GateType::CXSWAP: undo_CXSWAP(inst); break; + case GateType::CZSWAP: + undo_CZSWAP(inst); + break; case GateType::SWAPCX: undo_SWAPCX(inst); break; @@ -609,6 +612,9 @@ void ErrorAnalyzer::undo_ISWAP(const CircuitInstruction &dat) { void ErrorAnalyzer::undo_CXSWAP(const CircuitInstruction &dat) { tracker.undo_CXSWAP(dat); } +void ErrorAnalyzer::undo_CZSWAP(const CircuitInstruction &dat) { + tracker.undo_CZSWAP(dat); +} void ErrorAnalyzer::undo_SWAPCX(const CircuitInstruction &dat) { tracker.undo_SWAPCX(dat); } diff --git a/src/stim/simulators/error_analyzer.h b/src/stim/simulators/error_analyzer.h index 3a6ee1240..2a08b2322 100644 --- a/src/stim/simulators/error_analyzer.h +++ b/src/stim/simulators/error_analyzer.h @@ -214,6 +214,7 @@ struct ErrorAnalyzer { void undo_PAULI_CHANNEL_2(const CircuitInstruction &inst); void undo_ISWAP(const CircuitInstruction &inst); void undo_CXSWAP(const CircuitInstruction &inst); + void undo_CZSWAP(const CircuitInstruction &inst); void undo_SWAPCX(const CircuitInstruction &inst); void undo_RX_with_context(const CircuitInstruction &inst, const char *context_op); diff --git a/src/stim/simulators/error_matcher.cc b/src/stim/simulators/error_matcher.cc index e8c860326..edf00b6d9 100644 --- a/src/stim/simulators/error_matcher.cc +++ b/src/stim/simulators/error_matcher.cc @@ -267,7 +267,7 @@ void ErrorMatcher::rev_process_instruction(const CircuitInstruction &op) { } else if (op.gate_type == GateType::M || op.gate_type == GateType::MR) { err_m(op, TARGET_PAULI_Z_BIT); } else { - throw std::invalid_argument("Not implemented: " + std::string(GATE_DATA[op.gate_type].name)); + throw std::invalid_argument("Not implemented in ErrorMatcher::rev_process_instruction: " + std::string(GATE_DATA[op.gate_type].name)); } } diff --git a/src/stim/simulators/frame_simulator.h b/src/stim/simulators/frame_simulator.h index aff1a18df..9ea036082 100644 --- a/src/stim/simulators/frame_simulator.h +++ b/src/stim/simulators/frame_simulator.h @@ -120,6 +120,7 @@ struct FrameSimulator { void do_SWAP(const CircuitInstruction &inst); void do_ISWAP(const CircuitInstruction &inst); void do_CXSWAP(const CircuitInstruction &inst); + void do_CZSWAP(const CircuitInstruction &inst); void do_SWAPCX(const CircuitInstruction &inst); void do_MPP(const CircuitInstruction &inst); void do_MXX(const CircuitInstruction &inst); diff --git a/src/stim/simulators/frame_simulator.inl b/src/stim/simulators/frame_simulator.inl index 152642238..b2ed4a14c 100644 --- a/src/stim/simulators/frame_simulator.inl +++ b/src/stim/simulators/frame_simulator.inl @@ -504,6 +504,17 @@ void FrameSimulator::do_CXSWAP(const CircuitInstruction &target_data) { }); } +template +void FrameSimulator::do_CZSWAP(const CircuitInstruction &target_data) { + for_each_target_pair( + *this, target_data, [](simd_word &x1, simd_word &z1, simd_word &x2, simd_word &z2) { + std::swap(z1, z2); + std::swap(x1, x2); + z1 ^= x2; + z2 ^= x1; + }); +} + template void FrameSimulator::do_SWAPCX(const CircuitInstruction &target_data) { for_each_target_pair( @@ -1006,6 +1017,9 @@ void FrameSimulator::do_gate(const CircuitInstruction &inst) { case GateType::CXSWAP: do_CXSWAP(inst); break; + case GateType::CZSWAP: + do_CZSWAP(inst); + break; case GateType::SWAPCX: do_SWAPCX(inst); break; @@ -1065,7 +1079,7 @@ void FrameSimulator::do_gate(const CircuitInstruction &inst) { break; default: - throw std::invalid_argument("Not implemented: " + inst.str()); + throw std::invalid_argument("Not implemented in FrameSimulator::do_gate: " + inst.str()); } } diff --git a/src/stim/simulators/graph_simulator.cc b/src/stim/simulators/graph_simulator.cc index 1b5d2a250..55e46fbba 100644 --- a/src/stim/simulators/graph_simulator.cc +++ b/src/stim/simulators/graph_simulator.cc @@ -12,8 +12,8 @@ GraphSimulator::GraphSimulator(size_t num_qubits) void GraphSimulator::do_1q_gate(GateType gate, size_t qubit) { GateTarget t = GateTarget::qubit(qubit); - x2outs.ref().after_inplace(CircuitInstruction{gate, {}, &t}, false); - z2outs.ref().after_inplace(CircuitInstruction{gate, {}, &t}, false); + x2outs.ref().do_instruction(CircuitInstruction{gate, {}, &t}); + z2outs.ref().do_instruction(CircuitInstruction{gate, {}, &t}); paulis.xs[qubit] ^= z2outs.sign; paulis.zs[qubit] ^= x2outs.sign; x2outs.sign = 0; diff --git a/src/stim/simulators/sparse_rev_frame_tracker.cc b/src/stim/simulators/sparse_rev_frame_tracker.cc index 62d1de9d6..ef5a1925b 100644 --- a/src/stim/simulators/sparse_rev_frame_tracker.cc +++ b/src/stim/simulators/sparse_rev_frame_tracker.cc @@ -95,6 +95,9 @@ void SparseUnsignedRevFrameTracker::undo_gate(const CircuitInstruction &inst) { case GateType::CXSWAP: undo_CXSWAP(inst); break; + case GateType::CZSWAP: + undo_CZSWAP(inst); + break; case GateType::SWAPCX: undo_SWAPCX(inst); break; @@ -729,6 +732,17 @@ void SparseUnsignedRevFrameTracker::undo_CXSWAP(const CircuitInstruction &dat) { } } +void SparseUnsignedRevFrameTracker::undo_CZSWAP(const CircuitInstruction &dat) { + for (size_t k = dat.targets.size() - 2; k + 2 != 0; k -= 2) { + auto a = dat.targets[k].data; + auto b = dat.targets[k + 1].data; + zs[a] ^= xs[b]; + zs[b] ^= xs[a]; + std::swap(xs[a], xs[b]); + std::swap(zs[a], zs[b]); + } +} + void SparseUnsignedRevFrameTracker::undo_SWAPCX(const CircuitInstruction &dat) { for (size_t k = dat.targets.size() - 2; k + 2 != 0; k -= 2) { auto a = dat.targets[k].data; diff --git a/src/stim/simulators/sparse_rev_frame_tracker.h b/src/stim/simulators/sparse_rev_frame_tracker.h index 6d422ca3b..acebecb32 100644 --- a/src/stim/simulators/sparse_rev_frame_tracker.h +++ b/src/stim/simulators/sparse_rev_frame_tracker.h @@ -113,6 +113,7 @@ struct SparseUnsignedRevFrameTracker { void undo_SWAP(const CircuitInstruction &inst); void undo_ISWAP(const CircuitInstruction &inst); void undo_CXSWAP(const CircuitInstruction &inst); + void undo_CZSWAP(const CircuitInstruction &inst); void undo_SWAPCX(const CircuitInstruction &inst); template diff --git a/src/stim/simulators/tableau_simulator.h b/src/stim/simulators/tableau_simulator.h index c4b11acf6..b67f1d4ab 100644 --- a/src/stim/simulators/tableau_simulator.h +++ b/src/stim/simulators/tableau_simulator.h @@ -134,6 +134,7 @@ struct TableauSimulator { void do_ISWAP(const CircuitInstruction &inst); void do_ISWAP_DAG(const CircuitInstruction &inst); void do_CXSWAP(const CircuitInstruction &inst); + void do_CZSWAP(const CircuitInstruction &inst); void do_SWAPCX(const CircuitInstruction &inst); void do_XCX(const CircuitInstruction &inst); void do_XCY(const CircuitInstruction &inst); diff --git a/src/stim/simulators/tableau_simulator.inl b/src/stim/simulators/tableau_simulator.inl index bde8290f0..4fa7713fc 100644 --- a/src/stim/simulators/tableau_simulator.inl +++ b/src/stim/simulators/tableau_simulator.inl @@ -752,6 +752,18 @@ void TableauSimulator::do_CXSWAP(const CircuitInstruction &target_data) { } } +template +void TableauSimulator::do_CZSWAP(const CircuitInstruction &target_data) { + const auto &targets = target_data.targets; + assert(!(targets.size() & 1)); + for (size_t k = 0; k < targets.size(); k += 2) { + auto q1 = targets[k].data; + auto q2 = targets[k + 1].data; + inv_state.prepend_ZCZ(q1, q2); + inv_state.prepend_SWAP(q2, q1); + } +} + template void TableauSimulator::do_SWAPCX(const CircuitInstruction &target_data) { const auto &targets = target_data.targets; @@ -1673,6 +1685,9 @@ void TableauSimulator::do_gate(const CircuitInstruction &inst) { case GateType::CXSWAP: do_CXSWAP(inst); break; + case GateType::CZSWAP: + do_CZSWAP(inst); + break; case GateType::SWAPCX: do_SWAPCX(inst); break; diff --git a/src/stim/stabilizers/pauli_string.test.cc b/src/stim/stabilizers/pauli_string.test.cc index 60b359ecb..b58bbe151 100644 --- a/src/stim/stabilizers/pauli_string.test.cc +++ b/src/stim/stabilizers/pauli_string.test.cc @@ -522,8 +522,8 @@ TEST_EACH_WORD_SIZE_W(pauli_string, before_after_circuit_understands_commutation MPP X2*Y3*Z4 X5*X6 H 1 )CIRCUIT"); - auto before = PauliString::from_str("+_X"); - auto after = PauliString::from_str("+_Z"); + auto before = PauliString::from_str("+_X_____"); + auto after = PauliString::from_str("+_Z_____"); ASSERT_EQ(before.ref().after(c), after); ASSERT_EQ(after.ref().before(c), before); @@ -532,12 +532,12 @@ TEST_EACH_WORD_SIZE_W(pauli_string, before_after_circuit_understands_commutation ASSERT_EQ(before.ref().after(c), after); ASSERT_EQ(after.ref().before(c), before); - before = PauliString::from_str("+_XX___"); - after = PauliString::from_str("+_ZX___"); + before = PauliString::from_str("+_XX____"); + after = PauliString::from_str("+_ZX____"); ASSERT_EQ(before.ref().after(c), after); ASSERT_EQ(after.ref().before(c), before); - before = after = PauliString::from_str("+__ZX"); + before = after = PauliString::from_str("+__ZX___"); ASSERT_EQ(before.ref().after(c), after); ASSERT_EQ(after.ref().before(c), before); diff --git a/src/stim/stabilizers/pauli_string_ref.h b/src/stim/stabilizers/pauli_string_ref.h index 365f8a684..fcb0779a2 100644 --- a/src/stim/stabilizers/pauli_string_ref.h +++ b/src/stim/stabilizers/pauli_string_ref.h @@ -118,9 +118,19 @@ struct PauliStringRef { /// Returns a string describing the given Pauli string, indexing the Paulis so that identities can be omitted. std::string sparse_str() const; - void after_inplace_broadcast(const Tableau &tableau, SpanRef targets, bool inverse); - void after_inplace(const Circuit &Circuit); - void after_inplace(const CircuitInstruction &operation, bool inverse); + /// Applies the given tableau to the pauli string, at the given targets. + /// + /// Args: + /// tableau: The Clifford operation to apply. + /// targets: The qubits to target. Broadcasting is supported. The length of the span must be a multiple of the + /// tableau's size. + /// inverse: When true, applies the inverse of the tableau instead of the tableau. + void do_tableau(const Tableau &tableau, SpanRef targets, bool inverse); + void do_circuit(const Circuit &circuit); + void undo_circuit(const Circuit &circuit); + void do_instruction(const CircuitInstruction &inst); + void undo_instruction(const CircuitInstruction &inst); + PauliString after(const Circuit &circuit) const; PauliString after(const Tableau &tableau, SpanRef indices) const; PauliString after(const CircuitInstruction &operation) const; @@ -129,6 +139,63 @@ struct PauliStringRef { PauliString before(const CircuitInstruction &operation) const; size_t weight() const; + + private: + void check_avoids_MPP(const CircuitInstruction &inst); + void check_avoids_reset(const CircuitInstruction &inst); + void check_avoids_measurement(const CircuitInstruction &inst); + + void do_single_cx(const CircuitInstruction &inst, uint32_t c, uint32_t t); + void do_single_cy(const CircuitInstruction &inst, uint32_t c, uint32_t t); + void do_single_cz(const CircuitInstruction &inst, uint32_t c, uint32_t t); + + void do_H_XZ(const CircuitInstruction &inst); + void do_H_YZ(const CircuitInstruction &inst); + void do_H_XY(const CircuitInstruction &inst); + void do_C_XYZ(const CircuitInstruction &inst); + void do_C_ZYX(const CircuitInstruction &inst); + void do_SQRT_X(const CircuitInstruction &inst); + void do_SQRT_Y(const CircuitInstruction &inst); + void do_SQRT_Z(const CircuitInstruction &inst); + void do_SQRT_X_DAG(const CircuitInstruction &inst); + void do_SQRT_Y_DAG(const CircuitInstruction &inst); + void do_SQRT_Z_DAG(const CircuitInstruction &inst); + void do_SQRT_XX(const CircuitInstruction &inst); + void do_SQRT_XX_DAG(const CircuitInstruction &inst); + void do_SQRT_YY(const CircuitInstruction &inst); + void do_SQRT_YY_DAG(const CircuitInstruction &inst); + void do_SQRT_ZZ(const CircuitInstruction &inst); + void do_SQRT_ZZ_DAG(const CircuitInstruction &inst); + template + void do_ZCX(const CircuitInstruction &inst); + template + void do_ZCY(const CircuitInstruction &inst); + void do_ZCZ(const CircuitInstruction &inst); + template + void do_SWAP(const CircuitInstruction &inst); + void do_X(const CircuitInstruction &inst); + void do_Y(const CircuitInstruction &inst); + void do_Z(const CircuitInstruction &inst); + template + void do_ISWAP(const CircuitInstruction &inst); + template + void do_ISWAP_DAG(const CircuitInstruction &inst); + template + void do_CXSWAP(const CircuitInstruction &inst); + template + void do_CZSWAP(const CircuitInstruction &inst); + template + void do_SWAPCX(const CircuitInstruction &inst); + void do_XCX(const CircuitInstruction &inst); + template + void do_XCY(const CircuitInstruction &inst); + template + void do_XCZ(const CircuitInstruction &inst); + template + void do_YCX(const CircuitInstruction &inst); + void do_YCY(const CircuitInstruction &inst); + template + void do_YCZ(const CircuitInstruction &inst); }; /// Writes a string describing the given Pauli string to an output stream. diff --git a/src/stim/stabilizers/pauli_string_ref.inl b/src/stim/stabilizers/pauli_string_ref.inl index 522c446eb..f29e0e798 100644 --- a/src/stim/stabilizers/pauli_string_ref.inl +++ b/src/stim/stabilizers/pauli_string_ref.inl @@ -140,7 +140,7 @@ bool PauliStringRef::commutes(const PauliStringRef &other) const noexcept } template -void PauliStringRef::after_inplace_broadcast( +void PauliStringRef::do_tableau( const Tableau &tableau, SpanRef indices, bool inverse) { if (tableau.num_qubits == 0 || indices.size() % tableau.num_qubits != 0) { throw std::invalid_argument("len(tableau) == 0 or len(indices) % len(tableau) != 0"); @@ -164,148 +164,468 @@ void PauliStringRef::after_inplace_broadcast( } template -void PauliStringRef::after_inplace(const Circuit &circuit) { - for (const auto &op : circuit.operations) { - if (op.gate_type == GateType::REPEAT) { - const auto &body = op.repeat_block_body(circuit); - auto reps = op.repeat_block_rep_count(); - for (size_t k = 0; k < reps; k++) { - after_inplace(body); - } - } else { - after_inplace(op, false); +void PauliStringRef::undo_circuit(const Circuit &circuit) { + circuit.for_each_operation_reverse([&](const CircuitInstruction &inst) { + undo_instruction(inst); + }); +} + +template +void PauliStringRef::do_circuit(const Circuit &circuit) { + circuit.for_each_operation([&](const CircuitInstruction &inst) { + do_instruction(inst); + }); +} + +template +void PauliStringRef::check_avoids_measurement(const CircuitInstruction &inst) { + bool x_dep, z_dep; + if (inst.gate_type == GateType::M) { + x_dep = true; + z_dep = false; + } else if (inst.gate_type == GateType::MX) { + x_dep = false; + z_dep = true; + } else if (inst.gate_type == GateType::MY) { + x_dep = true; + z_dep = true; + } else { + throw std::invalid_argument("Unrecognized measurement type: " + inst.str()); + } + for (const auto &t : inst.targets) { + assert(t.is_qubit_target()); + auto q = t.qubit_value(); + if (q < num_qubits && ((xs[q] & x_dep) ^ (zs[q] & z_dep))) { + std::stringstream ss; + ss << "The pauli observable '" << *this; + ss << "' doesn't have a well specified value after '" << inst; + ss << "' because it anticommutes with the measurement."; + throw std::invalid_argument(ss.str()); } } } template -void PauliStringRef::after_inplace(const CircuitInstruction &operation, bool inverse) { - const auto &gate_data = GATE_DATA[operation.gate_type]; - if (gate_data.flags & GATE_IS_UNITARY) { - // TODO: use hand-optimized methods instead of the generic tableau method. - std::vector indices; - for (auto t : operation.targets) { - if (!t.is_qubit_target()) { - throw std::invalid_argument("Operation isn't unitary: " + operation.str()); - } - if (t.qubit_value() >= num_qubits) { - throw std::invalid_argument("Operation reaches past end of pauli string: " + operation.str()); - } - indices.push_back(t.qubit_value()); +void PauliStringRef::check_avoids_reset(const CircuitInstruction &inst) { + // Only fail if the pauli string actually touches the reset. + for (const auto &t : inst.targets) { + assert(t.is_qubit_target()); + auto q = t.qubit_value(); + if (q < num_qubits && (xs[q] || zs[q])) { + std::stringstream ss; + ss << "The pauli observable '" << *this; + ss << "' doesn't have a well specified value after '" << inst; + ss << "' because the reset discards information."; + throw std::invalid_argument(ss.str()); } - after_inplace_broadcast(gate_data.tableau(), indices, inverse); - } else if (gate_data.flags & GATE_HAS_NO_EFFECT_ON_QUBITS) { - // Gate can be ignored. - } else if (gate_data.flags & GATE_IS_RESET) { - // Only fail if the pauli string actually touches the reset. - for (const auto &t : operation.targets) { - assert(t.is_qubit_target()); + } +} + +template +void PauliStringRef::check_avoids_MPP(const CircuitInstruction &inst) { + size_t start = 0; + const auto &targets = inst.targets; + while (start < targets.size()) { + size_t end = start + 1; + bool anticommutes = false; + while (true) { + auto t = targets[end - 1]; auto q = t.qubit_value(); - if (q < num_qubits && (xs[q] || zs[q])) { - std::stringstream ss; - ss << "The pauli observable '" << *this << "' doesn't have a well specified value after '" << operation - << "' because the reset discards information."; - throw std::invalid_argument(ss.str()); + if (q < num_qubits) { + anticommutes ^= zs[q] && (t.data & TARGET_PAULI_X_BIT); + anticommutes ^= xs[q] && (t.data & TARGET_PAULI_Z_BIT); } - } - } else if (operation.gate_type == GateType::MPAD) { - // No effect. - } else if (operation.gate_type == GateType::MPP) { - size_t start = 0; - const auto &targets = operation.targets; - while (start < targets.size()) { - size_t end = start + 1; - bool anticommutes = false; - while (true) { - auto t = targets[end - 1]; - auto q = t.qubit_value(); - if (q < num_qubits) { - anticommutes ^= zs[q] && (t.data & TARGET_PAULI_X_BIT); - anticommutes ^= xs[q] && (t.data & TARGET_PAULI_Z_BIT); - } - if (end >= targets.size() || !targets[end].is_combiner()) { - break; - } - end += 2; + if (end >= targets.size() || !targets[end].is_combiner()) { + break; } - if (anticommutes) { - std::stringstream ss; - ss << "The pauli observable '" << *this << "' doesn't have a well specified value after '" << operation - << "' because it anticommutes with the measurement."; - throw std::invalid_argument(ss.str()); - } - start = end; + end += 2; } - } else if (gate_data.flags & GATE_PRODUCES_RESULTS) { - bool x_dep, z_dep; - if (operation.gate_type == GateType::M) { - x_dep = true; - z_dep = false; - } else if (operation.gate_type == GateType::MX) { - x_dep = false; - z_dep = true; - } else if (operation.gate_type == GateType::MY) { - x_dep = true; - z_dep = true; - } else { - throw std::invalid_argument("Unrecognized measurement type: " + operation.str()); + if (anticommutes) { + std::stringstream ss; + ss << "The pauli observable '" << *this; + ss << "' doesn't have a well specified value after '" << inst; + ss << "' because it anticommutes with the measurement."; + throw std::invalid_argument(ss.str()); } - for (const auto &t : operation.targets) { - assert(t.is_qubit_target()); - auto q = t.qubit_value(); - if (q < num_qubits && ((xs[q] & x_dep) ^ (zs[q] & z_dep))) { - std::stringstream ss; - ss << "The pauli observable '" << *this << "' doesn't have a well specified value after '" << operation - << "' because it anticommutes with the measurement."; - throw std::invalid_argument(ss.str()); - } + start = end; + } +} + +template +void PauliStringRef::do_instruction(const CircuitInstruction &inst) { + for (const auto &t : inst.targets) { + if (t.has_qubit_value() && t.qubit_value() >= num_qubits && !(GATE_DATA[inst.gate_type].flags & GATE_HAS_NO_EFFECT_ON_QUBITS)) { + std::stringstream ss; + ss << "The instruction '" << inst; + ss << "' targets qubits outside the pauli string '" << *this; + ss << "'."; + throw std::invalid_argument(ss.str()); } - } else { - std::stringstream ss; - ss << "The pauli string '" << *this << "' doesn't have a well defined deterministic value after '" << operation - << "'."; - throw std::invalid_argument(ss.str()); + } + + const auto &gate_data = GATE_DATA[inst.gate_type]; + switch (gate_data.id) { + case GateType::H: + do_H_XZ(inst); + break; + case GateType::H_YZ: + do_H_YZ(inst); + break; + case GateType::H_XY: + do_H_XY(inst); + break; + case GateType::C_XYZ: + do_C_XYZ(inst); + break; + case GateType::C_ZYX: + do_C_ZYX(inst); + break; + case GateType::SQRT_X: + do_SQRT_X(inst); + break; + case GateType::SQRT_Y: + do_SQRT_Y(inst); + break; + case GateType::S: + do_SQRT_Z(inst); + break; + case GateType::SQRT_X_DAG: + do_SQRT_X_DAG(inst); + break; + case GateType::SQRT_Y_DAG: + do_SQRT_Y_DAG(inst); + break; + case GateType::S_DAG: + do_SQRT_Z_DAG(inst); + break; + case GateType::SQRT_XX: + do_SQRT_XX(inst); + break; + case GateType::SQRT_XX_DAG: + do_SQRT_XX_DAG(inst); + break; + case GateType::SQRT_YY: + do_SQRT_YY(inst); + break; + case GateType::SQRT_YY_DAG: + do_SQRT_YY_DAG(inst); + break; + case GateType::SQRT_ZZ: + do_SQRT_ZZ(inst); + break; + case GateType::SQRT_ZZ_DAG: + do_SQRT_ZZ_DAG(inst); + break; + case GateType::CX: + do_ZCX(inst); + break; + case GateType::CY: + do_ZCY(inst); + break; + case GateType::CZ: + do_ZCZ(inst); + break; + case GateType::SWAP: + do_SWAP(inst); + break; + case GateType::X: + do_X(inst); + break; + case GateType::Y: + do_Y(inst); + break; + case GateType::Z: + do_Z(inst); + break; + case GateType::ISWAP: + do_ISWAP(inst); + break; + case GateType::ISWAP_DAG: + do_ISWAP_DAG(inst); + break; + case GateType::CXSWAP: + do_CXSWAP(inst); + break; + case GateType::CZSWAP: + do_CZSWAP(inst); + break; + case GateType::SWAPCX: + do_SWAPCX(inst); + break; + case GateType::XCX: + do_XCX(inst); + break; + case GateType::XCY: + do_XCY(inst); + break; + case GateType::XCZ: + do_XCZ(inst); + break; + case GateType::YCX: + do_YCX(inst); + break; + case GateType::YCY: + do_YCY(inst); + break; + case GateType::YCZ: + do_YCZ(inst); + break; + + case GateType::DETECTOR: + case GateType::OBSERVABLE_INCLUDE: + case GateType::TICK: + case GateType::QUBIT_COORDS: + case GateType::SHIFT_COORDS: + case GateType::MPAD: + case GateType::I: + // No effect. + break; + + case GateType::R: + case GateType::RX: + case GateType::RY: + case GateType::MR: + case GateType::MRX: + case GateType::MRY: + check_avoids_reset(inst); + break; + + case GateType::M: + case GateType::MX: + case GateType::MY: + check_avoids_measurement(inst); + break; + + case GateType::MPP: + check_avoids_MPP(inst); + break; + + case GateType::X_ERROR: + case GateType::Y_ERROR: + case GateType::Z_ERROR: + case GateType::DEPOLARIZE1: + case GateType::DEPOLARIZE2: + case GateType::E: + case GateType::ELSE_CORRELATED_ERROR: { + std::stringstream ss; + ss << "The pauli string '" << *this; + ss << "' doesn't have a well defined deterministic value after '" << inst; + ss << "'."; + throw std::invalid_argument(ss.str()); + } + + default: + throw std::invalid_argument("Not implemented in PauliStringRef::do_instruction: " + inst.str()); + } +} + +template +void PauliStringRef::undo_instruction(const CircuitInstruction &inst) { + for (const auto &t : inst.targets) { + if (t.has_qubit_value() && t.qubit_value() >= num_qubits && !(GATE_DATA[inst.gate_type].flags & GATE_HAS_NO_EFFECT_ON_QUBITS)) { + std::stringstream ss; + ss << "The instruction '" << inst; + ss << "' targets qubits outside the pauli string '" << *this; + ss << "'."; + throw std::invalid_argument(ss.str()); + } + } + + const auto &gate_data = GATE_DATA[inst.gate_type]; + switch (gate_data.id) { + case GateType::H: + do_H_XZ(inst); + break; + case GateType::H_YZ: + do_H_YZ(inst); + break; + case GateType::H_XY: + do_H_XY(inst); + break; + case GateType::C_XYZ: + do_C_ZYX(inst); + break; + case GateType::C_ZYX: + do_C_XYZ(inst); + break; + case GateType::SQRT_X: + do_SQRT_X_DAG(inst); + break; + case GateType::SQRT_Y: + do_SQRT_Y_DAG(inst); + break; + case GateType::S: + do_SQRT_Z_DAG(inst); + break; + case GateType::SQRT_X_DAG: + do_SQRT_X(inst); + break; + case GateType::SQRT_Y_DAG: + do_SQRT_Y(inst); + break; + case GateType::S_DAG: + do_SQRT_Z(inst); + break; + case GateType::SQRT_XX: + do_SQRT_XX_DAG(inst); + break; + case GateType::SQRT_XX_DAG: + do_SQRT_XX(inst); + break; + case GateType::SQRT_YY: + do_SQRT_YY_DAG(inst); + break; + case GateType::SQRT_YY_DAG: + do_SQRT_YY(inst); + break; + case GateType::SQRT_ZZ: + do_SQRT_ZZ_DAG(inst); + break; + case GateType::SQRT_ZZ_DAG: + do_SQRT_ZZ(inst); + break; + case GateType::CX: + do_ZCX(inst); + break; + case GateType::CY: + do_ZCY(inst); + break; + case GateType::CZ: + do_ZCZ(inst); + break; + case GateType::SWAP: + do_SWAP(inst); + break; + case GateType::X: + do_X(inst); + break; + case GateType::Y: + do_Y(inst); + break; + case GateType::Z: + do_Z(inst); + break; + case GateType::ISWAP: + do_ISWAP_DAG(inst); + break; + case GateType::ISWAP_DAG: + do_ISWAP(inst); + break; + case GateType::CXSWAP: + do_SWAPCX(inst); + break; + case GateType::CZSWAP: + do_CZSWAP(inst); + break; + case GateType::SWAPCX: + do_CXSWAP(inst); + break; + case GateType::XCX: + do_XCX(inst); + break; + case GateType::XCY: + do_XCY(inst); + break; + case GateType::XCZ: + do_XCZ(inst); + break; + case GateType::YCX: + do_YCX(inst); + break; + case GateType::YCY: + do_YCY(inst); + break; + case GateType::YCZ: + do_YCZ(inst); + break; + + case GateType::DETECTOR: + case GateType::OBSERVABLE_INCLUDE: + case GateType::TICK: + case GateType::QUBIT_COORDS: + case GateType::SHIFT_COORDS: + case GateType::MPAD: + case GateType::I: + // No effect. + break; + + case GateType::R: + case GateType::RX: + case GateType::RY: + case GateType::MR: + case GateType::MRX: + case GateType::MRY: + check_avoids_reset(inst); + break; + + case GateType::M: + case GateType::MX: + case GateType::MY: + check_avoids_measurement(inst); + break; + + case GateType::MPP: + check_avoids_MPP(inst); + break; + + case GateType::X_ERROR: + case GateType::Y_ERROR: + case GateType::Z_ERROR: + case GateType::DEPOLARIZE1: + case GateType::DEPOLARIZE2: + case GateType::E: + case GateType::ELSE_CORRELATED_ERROR: { + std::stringstream ss; + ss << "The pauli string '" << *this; + ss << "' doesn't have a well defined deterministic value before '" << inst; + ss << "'."; + throw std::invalid_argument(ss.str()); + } + + default: + throw std::invalid_argument("Not implemented in PauliStringRef::undo_instruction: " + inst.str()); } } template PauliString PauliStringRef::after(const Circuit &circuit) const { PauliString result = *this; - result.ref().after_inplace(circuit); + result.ref().do_circuit(circuit); return result; } template PauliString PauliStringRef::after(const Tableau &tableau, SpanRef indices) const { PauliString result = *this; - result.ref().after_inplace_broadcast(tableau, indices, false); + result.ref().do_tableau(tableau, indices, false); return result; } template -PauliString PauliStringRef::after(const CircuitInstruction &operation) const { +PauliString PauliStringRef::after(const CircuitInstruction &inst) const { PauliString result = *this; - result.ref().after_inplace(operation, false); + result.ref().do_instruction(inst); return result; } template PauliString PauliStringRef::before(const Circuit &circuit) const { - // TODO: use hand-optimized methods instead of the generic circuit inverse method. - return after(circuit.inverse(true)); + PauliString result = *this; + result.ref().undo_circuit(circuit); + return result; } template -PauliString PauliStringRef::before(const CircuitInstruction &operation) const { +PauliString PauliStringRef::before(const CircuitInstruction &inst) const { PauliString result = *this; - result.ref().after_inplace(operation, true); + result.ref().undo_instruction(inst); return result; } template PauliString PauliStringRef::before(const Tableau &tableau, SpanRef indices) const { PauliString result = *this; - result.ref().after_inplace_broadcast(tableau, indices, true); + result.ref().do_tableau(tableau, indices, true); return result; } @@ -348,4 +668,491 @@ std::ostream &operator<<(std::ostream &out, const PauliStringRef &ps) { return out; } +template +void PauliStringRef::do_H_XZ(const CircuitInstruction &inst) { + for (auto t : inst.targets) { + auto q = t.data; + xs[q].swap_with(zs[q]); + sign ^= xs[q] && zs[q]; + } +} + +template +void PauliStringRef::do_SQRT_Y(const CircuitInstruction &inst) { + for (auto t : inst.targets) { + auto q = t.data; + xs[q].swap_with(zs[q]); + sign ^= !xs[q] && zs[q]; + } +} + +template +void PauliStringRef::do_SQRT_Y_DAG(const CircuitInstruction &inst) { + for (auto t : inst.targets) { + auto q = t.data; + xs[q].swap_with(zs[q]); + sign ^= xs[q] && !zs[q]; + } +} + +template +void PauliStringRef::do_H_XY(const CircuitInstruction &inst) { + for (auto t : inst.targets) { + auto q = t.data; + zs[q] ^= xs[q]; + sign ^= !xs[q] && zs[q]; + } +} + +template +void PauliStringRef::do_SQRT_Z(const CircuitInstruction &inst) { + for (auto t : inst.targets) { + auto q = t.data; + zs[q] ^= xs[q]; + sign ^= xs[q] && !zs[q]; + } +} + +template +void PauliStringRef::do_SQRT_Z_DAG(const CircuitInstruction &inst) { + for (auto t : inst.targets) { + auto q = t.data; + zs[q] ^= xs[q]; + sign ^= xs[q] && zs[q]; + } +} + +template +void PauliStringRef::do_H_YZ(const CircuitInstruction &inst) { + for (auto t : inst.targets) { + auto q = t.data; + xs[q] ^= zs[q]; + sign ^= xs[q] && !zs[q]; + } +} + +template +void PauliStringRef::do_SQRT_X(const CircuitInstruction &inst) { + for (auto t : inst.targets) { + auto q = t.data; + xs[q] ^= zs[q]; + sign ^= xs[q] && zs[q]; + } +} + +template +void PauliStringRef::do_SQRT_X_DAG(const CircuitInstruction &inst) { + for (auto t : inst.targets) { + auto q = t.data; + xs[q] ^= zs[q]; + sign ^= !xs[q] && zs[q]; + } +} + +template +void PauliStringRef::do_C_XYZ(const CircuitInstruction &inst) { + for (auto t : inst.targets) { + auto q = t.data; + xs[q] ^= zs[q]; + zs[q] ^= xs[q]; + } +} + +template +void PauliStringRef::do_C_ZYX(const CircuitInstruction &inst) { + for (auto t : inst.targets) { + auto q = t.data; + zs[q] ^= xs[q]; + xs[q] ^= zs[q]; + } +} + +template +void PauliStringRef::do_X(const CircuitInstruction &inst) { + for (auto t : inst.targets) { + auto q = t.data; + sign ^= zs[q]; + } +} + +template +void PauliStringRef::do_Y(const CircuitInstruction &inst) { + for (auto t : inst.targets) { + auto q = t.data; + sign ^= xs[q] ^ zs[q]; + } +} + +template +void PauliStringRef::do_Z(const CircuitInstruction &inst) { + for (auto t : inst.targets) { + auto q = t.data; + sign ^= xs[q]; + } +} + +template +void PauliStringRef::do_single_cx(const CircuitInstruction &inst, uint32_t c, uint32_t t) { + c &= ~TARGET_INVERTED_BIT; + t &= ~TARGET_INVERTED_BIT; + if (!((c | t) & (TARGET_RECORD_BIT | TARGET_SWEEP_BIT))) { + bit_ref x1 = xs[c], x2 = xs[t], z1 = zs[c], z2 = zs[t]; + z1 ^= z2; + x2 ^= x1; + sign ^= x1 && z2 && (z1 == x2); + } else if (t & (TARGET_RECORD_BIT | TARGET_SWEEP_BIT)) { + throw std::invalid_argument( + "CX had a bit (" + GateTarget{t}.str() + ") as its target, instead of its control."); + } else { + if (zs[t]) { + std::stringstream ss; + ss << "The pauli observable '" << *this; + ss << "' is affected by a controlled operation in '" << inst; + ss << "' but the controlling measurement result isn't known."; + throw std::invalid_argument(ss.str()); + } + } +} + +template +void PauliStringRef::do_single_cy(const CircuitInstruction &inst, uint32_t c, uint32_t t) { + c &= ~TARGET_INVERTED_BIT; + t &= ~TARGET_INVERTED_BIT; + if (!((c | t) & (TARGET_RECORD_BIT | TARGET_SWEEP_BIT))) { + bit_ref x1 = xs[c], x2 = xs[t], z1 = zs[c], z2 = zs[t]; + z1 ^= x2 ^ z2; + z2 ^= x1; + x2 ^= x1; + sign ^= x1 && !z1 && x2 && !z2; + sign ^= x1 && z1 && !x2 && z2; + } else if (t & (TARGET_RECORD_BIT | TARGET_SWEEP_BIT)) { + throw std::invalid_argument( + "CY had a bit (" + GateTarget{t}.str() + ") as its target, instead of its control."); + } else { + if (xs[t] ^ zs[t]) { + std::stringstream ss; + ss << "The pauli observable '" << *this; + ss << "' is affected by a controlled operation in '" << inst; + ss << "' but the controlling measurement result isn't known."; + throw std::invalid_argument(ss.str()); + } + } +} + +template +void PauliStringRef::do_single_cz(const CircuitInstruction &inst, uint32_t c, uint32_t t) { + c &= ~TARGET_INVERTED_BIT; + t &= ~TARGET_INVERTED_BIT; + if (!((c | t) & (TARGET_RECORD_BIT | TARGET_SWEEP_BIT))) { + bit_ref x1 = xs[c], x2 = xs[t], z1 = zs[c], z2 = zs[t]; + z1 ^= x2; + z2 ^= x1; + sign ^= x1 && x2 && (z1 ^ z2); + } else { + bool bc = !(c & (TARGET_RECORD_BIT | TARGET_SWEEP_BIT)) && xs[c]; + bool bt = !(t & (TARGET_RECORD_BIT | TARGET_SWEEP_BIT)) && xs[t]; + if (bc || bt) { + std::stringstream ss; + ss << "The pauli observable '" << *this; + ss << "' is affected by a controlled operation in '" << inst; + ss << "' but the controlling measurement result isn't known."; + throw std::invalid_argument(ss.str()); + } + } +} + +template +template +void PauliStringRef::do_ZCX(const CircuitInstruction &inst) { + const auto &targets = inst.targets; + assert((targets.size() & 1) == 0); + for (size_t k = 0; k < inst.targets.size(); k += 2) { + size_t k2 = reverse_order ? inst.targets.size() - 2 - k : k; + size_t q1 = inst.targets[k2].data, q2 = inst.targets[k2 + 1].data; + do_single_cx(inst, q1, q2); + } +} + +template +template +void PauliStringRef::do_ZCY(const CircuitInstruction &inst) { + const auto &targets = inst.targets; + assert((targets.size() & 1) == 0); + for (size_t k = 0; k < inst.targets.size(); k += 2) { + size_t k2 = reverse_order ? inst.targets.size() - 2 - k : k; + size_t q1 = inst.targets[k2].data, q2 = inst.targets[k2 + 1].data; + do_single_cy(inst, q1, q2); + } +} + +template +void PauliStringRef::do_ZCZ(const CircuitInstruction &inst) { + const auto &targets = inst.targets; + assert((targets.size() & 1) == 0); + for (size_t k = 0; k < targets.size(); k += 2) { + do_single_cz(inst, targets[k].data, targets[k + 1].data); + } +} + +template +template +void PauliStringRef::do_SWAP(const CircuitInstruction &inst) { + const auto &targets = inst.targets; + assert((targets.size() & 1) == 0); + for (size_t k = 0; k < inst.targets.size(); k += 2) { + size_t k2 = reverse_order ? inst.targets.size() - 2 - k : k; + size_t q1 = inst.targets[k2].data, q2 = inst.targets[k2 + 1].data; + zs[q1].swap_with(zs[q2]); + xs[q1].swap_with(xs[q2]); + } +} + +template +template +void PauliStringRef::do_ISWAP(const CircuitInstruction &inst) { + for (size_t k = 0; k < inst.targets.size(); k += 2) { + size_t k2 = reverse_order ? inst.targets.size() - 2 - k : k; + size_t q1 = inst.targets[k2].data, q2 = inst.targets[k2 + 1].data; + bit_ref x1 = xs[q1], z1 = zs[q1], x2 = xs[q2], z2 = zs[q2]; + sign ^= x1 && z1 && !x2 && !z2; + sign ^= !x1 && !z1 && x2 && z2; + sign ^= (x1 ^ x2) && z1 && z2; + auto dx = x1 ^ x2; + z1 ^= dx; + z2 ^= dx; + z1.swap_with(z2); + x1.swap_with(x2); + } +} + +template +template +void PauliStringRef::do_ISWAP_DAG(const CircuitInstruction &inst) { + for (size_t k = 0; k < inst.targets.size(); k += 2) { + size_t k2 = reverse_order ? inst.targets.size() - 2 - k : k; + size_t q1 = inst.targets[k2].data, q2 = inst.targets[k2 + 1].data; + bit_ref x1 = xs[q1], z1 = zs[q1], x2 = xs[q2], z2 = zs[q2]; + auto dx = x1 ^ x2; + z1 ^= dx; + z2 ^= dx; + z1.swap_with(z2); + x1.swap_with(x2); + sign ^= x1 && z1 && !x2 && !z2; + sign ^= !x1 && !z1 && x2 && z2; + sign ^= (x1 ^ x2) && z1 && z2; + } +} + +template +template +void PauliStringRef::do_CXSWAP(const CircuitInstruction &inst) { + for (size_t k = 0; k < inst.targets.size(); k += 2) { + size_t k2 = reverse_order ? inst.targets.size() - 2 - k : k; + size_t q1 = inst.targets[k2].data, q2 = inst.targets[k2 + 1].data; + bit_ref x1 = xs[q1], z1 = zs[q1], x2 = xs[q2], z2 = zs[q2]; + sign ^= x1 && z2 && (z1 == x2); + z2 ^= z1; + z1 ^= z2; + x1 ^= x2; + x2 ^= x1; + } +} + +template +template +void PauliStringRef::do_CZSWAP(const CircuitInstruction &inst) { + for (size_t k = 0; k < inst.targets.size(); k += 2) { + size_t k2 = reverse_order ? inst.targets.size() - 2 - k : k; + size_t q1 = inst.targets[k2].data, q2 = inst.targets[k2 + 1].data; + bit_ref x1 = xs[q1], z1 = zs[q1], x2 = xs[q2], z2 = zs[q2]; + z1.swap_with(z2); + x1.swap_with(x2); + z1 ^= x2; + z2 ^= x1; + sign ^= x1 && x2 && (z1 ^ z2); + } +} + +template +template +void PauliStringRef::do_SWAPCX(const CircuitInstruction &inst) { + for (size_t k = 0; k < inst.targets.size(); k += 2) { + size_t k2 = reverse_order ? inst.targets.size() - 2 - k : k; + size_t q1 = inst.targets[k2].data, q2 = inst.targets[k2 + 1].data; + bit_ref x1 = xs[q1], z1 = zs[q1], x2 = xs[q2], z2 = zs[q2]; + z1 ^= z2; + z2 ^= z1; + x2 ^= x1; + x1 ^= x2; + sign ^= x1 && z2 && (z1 == x2); + } +} + +template +void PauliStringRef::do_SQRT_XX(const CircuitInstruction &inst) { + for (size_t k = 0; k < inst.targets.size(); k += 2) { + size_t q1 = inst.targets[k].data, q2 = inst.targets[k + 1].data; + bit_ref x1 = xs[q1], z1 = zs[q1], x2 = xs[q2], z2 = zs[q2]; + sign ^= !x1 && z1 && !z2; + sign ^= !x2 && !z1 && z2; + auto dz = z1 ^ z2; + x1 ^= dz; + x2 ^= dz; + } +} + +template +void PauliStringRef::do_SQRT_XX_DAG(const CircuitInstruction &inst) { + for (size_t k = 0; k < inst.targets.size(); k += 2) { + size_t q1 = inst.targets[k].data, q2 = inst.targets[k + 1].data; + bit_ref x1 = xs[q1], z1 = zs[q1], x2 = xs[q2], z2 = zs[q2]; + auto dz = z1 ^ z2; + x1 ^= dz; + x2 ^= dz; + sign ^= !x1 && z1 && !z2; + sign ^= !x2 && !z1 && z2; + } +} + +template +void PauliStringRef::do_SQRT_YY(const CircuitInstruction &inst) { + for (size_t k = 0; k < inst.targets.size(); k += 2) { + size_t q1 = inst.targets[k].data, q2 = inst.targets[k + 1].data; + bit_ref x1 = xs[q1], z1 = zs[q1], x2 = xs[q2], z2 = zs[q2]; + sign ^= x1 && z1 && x2 && !z2; + sign ^= x1 && !z1 && x2 && z2; + sign ^= x1 && !z1 && !x2 && !z2; + sign ^= !x1 && !z1 && x2 && !z2; + auto d = x1 ^ z1 ^ x2 ^ z2; + x1 ^= d; + z1 ^= d; + x2 ^= d; + z2 ^= d; + } +} + +template +void PauliStringRef::do_SQRT_YY_DAG(const CircuitInstruction &inst) { + for (size_t k = 0; k < inst.targets.size(); k += 2) { + size_t q1 = inst.targets[k].data, q2 = inst.targets[k + 1].data; + bit_ref x1 = xs[q1], z1 = zs[q1], x2 = xs[q2], z2 = zs[q2]; + auto d = x1 ^ z1 ^ x2 ^ z2; + x1 ^= d; + z1 ^= d; + x2 ^= d; + z2 ^= d; + sign ^= x1 && z1 && x2 && !z2; + sign ^= x1 && !z1 && x2 && z2; + sign ^= x1 && !z1 && !x2 && !z2; + sign ^= !x1 && !z1 && x2 && !z2; + } +} + +template +void PauliStringRef::do_SQRT_ZZ(const CircuitInstruction &inst) { + for (size_t k = 0; k < inst.targets.size(); k += 2) { + size_t q1 = inst.targets[k].data, q2 = inst.targets[k + 1].data; + bit_ref x1 = xs[q1], z1 = zs[q1], x2 = xs[q2], z2 = zs[q2]; + auto dx = x1 ^ x2; + z1 ^= dx; + z2 ^= dx; + sign ^= !z1 && x1 && !x2; + sign ^= !z2 && !x1 && x2; + } +} + +template +void PauliStringRef::do_SQRT_ZZ_DAG(const CircuitInstruction &inst) { + for (size_t k = 0; k < inst.targets.size(); k += 2) { + size_t q1 = inst.targets[k].data, q2 = inst.targets[k + 1].data; + bit_ref x1 = xs[q1], z1 = zs[q1], x2 = xs[q2], z2 = zs[q2]; + sign ^= !z1 && x1 && !x2; + sign ^= !z2 && !x1 && x2; + auto dx = x1 ^ x2; + z1 ^= dx; + z2 ^= dx; + } +} + +template +void PauliStringRef::do_XCX(const CircuitInstruction &inst) { + for (size_t k = 0; k < inst.targets.size(); k += 2) { + size_t q1 = inst.targets[k].data, q2 = inst.targets[k + 1].data; + bit_ref x1 = xs[q1], z1 = zs[q1], x2 = xs[q2], z2 = zs[q2]; + sign ^= (x1 != x2) && z1 && z2; + x1 ^= z2; + x2 ^= z1; + } +} + +template +template +void PauliStringRef::do_XCY(const CircuitInstruction &inst) { + for (size_t k = 0; k < inst.targets.size(); k += 2) { + size_t k2 = reverse_order ? inst.targets.size() - 2 - k : k; + size_t q1 = inst.targets[k2].data, q2 = inst.targets[k2 + 1].data; + bit_ref x1 = xs[q1], z1 = zs[q1], x2 = xs[q2], z2 = zs[q2]; + x1 ^= x2 ^ z2; + x2 ^= z1; + z2 ^= z1; + sign ^= !x1 && z1 && !x2 && z2; + sign ^= x1 && z1 && x2 && !z2; + } +} + +template +template +void PauliStringRef::do_XCZ(const CircuitInstruction &inst) { + const auto &targets = inst.targets; + assert((targets.size() & 1) == 0); + for (size_t k = 0; k < inst.targets.size(); k += 2) { + size_t k2 = reverse_order ? inst.targets.size() - 2 - k : k; + size_t q1 = inst.targets[k2].data, q2 = inst.targets[k2 + 1].data; + do_single_cx(inst, q2, q1); + } +} + +template +template +void PauliStringRef::do_YCX(const CircuitInstruction &inst) { + for (size_t k = 0; k < inst.targets.size(); k += 2) { + size_t k2 = reverse_order ? inst.targets.size() - 2 - k : k; + size_t q1 = inst.targets[k2].data, q2 = inst.targets[k2 + 1].data; + bit_ref x1 = xs[q1], z1 = zs[q1], x2 = xs[q2], z2 = zs[q2]; + x2 ^= x1 ^ z1; + x1 ^= z2; + z1 ^= z2; + sign ^= !x2 && z2 && !x1 && z1; + sign ^= x2 && z2 && x1 && !z1; + } +} + +template +void PauliStringRef::do_YCY(const CircuitInstruction &inst) { + for (size_t k = 0; k < inst.targets.size(); k += 2) { + size_t q1 = inst.targets[k].data, q2 = inst.targets[k + 1].data; + bit_ref x1 = xs[q1], z1 = zs[q1], x2 = xs[q2], z2 = zs[q2]; + bool y1 = x1 ^ z1; + bool y2 = x2 ^ z2; + x1 ^= y2; + z1 ^= y2; + x2 ^= y1; + z2 ^= y1; + sign ^= x1 && !z1 && !x2 && z2; + sign ^= !x1 && z1 && x2 && !z2; + } +} + +template +template +void PauliStringRef::do_YCZ(const CircuitInstruction &inst) { + const auto &targets = inst.targets; + assert((targets.size() & 1) == 0); + for (size_t k = 0; k < inst.targets.size(); k += 2) { + size_t k2 = reverse_order ? inst.targets.size() - 2 - k : k; + size_t q1 = inst.targets[k2].data, q2 = inst.targets[k2 + 1].data; + do_single_cy(inst, q2, q1); + } +} + } // namespace stim diff --git a/src/stim/stabilizers/pauli_string_ref.test.cc b/src/stim/stabilizers/pauli_string_ref.test.cc new file mode 100644 index 000000000..e730c82f8 --- /dev/null +++ b/src/stim/stabilizers/pauli_string_ref.test.cc @@ -0,0 +1,78 @@ +// Copyright 2021 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "stim/stabilizers/pauli_string_ref.h" + +#include "gtest/gtest.h" + +#include "stim/mem/simd_word.test.h" +#include "stim/simulators/tableau_simulator.h" +#include "stim/stabilizers/pauli_string.h" +#include "stim/test_util.test.h" + +using namespace stim; + +template +void check_pauli_string_do_instruction_agrees_with_tableau_sim(Gate gate, TableauSimulator &sim) { + std::vector targets{ + GateTarget::qubit(3), + GateTarget::qubit(5), + GateTarget::qubit(8), + GateTarget::qubit(5), + }; + CircuitInstruction inst{gate.id, {}, targets}; + + std::vector> before; + for (size_t k = 0; k < 16; k++) { + sim.inv_state.zs[k].sign = false; + before.push_back(sim.inv_state.zs[k]); + } + auto tableau = gate.tableau(); + if (gate.flags & GATE_TARGETS_PAIRS) { + sim.inv_state.inplace_scatter_append(tableau, {3, 5}); + sim.inv_state.inplace_scatter_append(tableau, {8, 5}); + } else { + sim.inv_state.inplace_scatter_append(tableau, {3}); + sim.inv_state.inplace_scatter_append(tableau, {5}); + sim.inv_state.inplace_scatter_append(tableau, {8}); + sim.inv_state.inplace_scatter_append(tableau, {5}); + } + + PauliString v(0); + for (size_t k = 0; k < before.size(); k++) { + v = before[k]; + v.ref().do_instruction(inst); + if (v != sim.inv_state.zs[k]) { + EXPECT_EQ(v, sim.inv_state.zs[k]) << "do_" << gate.name << "\nbefore=" << before[k]; + return; + } + + v.ref().undo_instruction(inst); + if (v != before[k]) { + EXPECT_EQ(v, sim.inv_state.zs[k]) << "undo_" << gate.name; + return; + } + } +} + +TEST_EACH_WORD_SIZE_W(pauli_string, do_instruction_agrees_with_tableau_sim, { + TableauSimulator sim(INDEPENDENT_TEST_RNG(), 16); + sim.inv_state = Tableau::random(sim.inv_state.num_qubits, sim.rng); + + for (const auto &gate : GATE_DATA.items) { + if (gate.flags & GATE_IS_UNITARY) { + check_pauli_string_do_instruction_agrees_with_tableau_sim(gate, sim); + } + } +}) diff --git a/testdata/circuit_all_ops_3d.gltf b/testdata/circuit_all_ops_3d.gltf index d20d88a6f..75c0eafc7 100644 --- a/testdata/circuit_all_ops_3d.gltf +++ b/testdata/circuit_all_ops_3d.gltf @@ -1 +1 @@ -{"accessors":[{"bufferView":0,"byteOffset":0,"componentType":5126,"count":12,"max":[0,0.5,0.5],"min":[0,-0.5,-0.5],"name":"cube","type":"VEC3"},{"bufferView":1,"byteOffset":0,"componentType":5126,"count":12,"max":[0.0625,0.4375],"min":[0,0.375],"name":"tex_coords_gate_I","type":"VEC2"},{"bufferView":2,"byteOffset":0,"componentType":5126,"count":12,"max":[0.0625,0.4375],"min":[0,0.375],"name":"tex_coords_gate_X","type":"VEC2"},{"bufferView":3,"byteOffset":0,"componentType":5126,"count":12,"max":[0.0625,0.5],"min":[0,0.4375],"name":"tex_coords_gate_Y","type":"VEC2"},{"bufferView":4,"byteOffset":0,"componentType":5126,"count":12,"max":[0.0625,0.5625],"min":[0,0.5],"name":"tex_coords_gate_Z","type":"VEC2"},{"bufferView":5,"byteOffset":0,"componentType":5126,"count":12,"max":[0.125,0.625],"min":[0.0625,0.5625],"name":"tex_coords_gate_C_XYZ","type":"VEC2"},{"bufferView":6,"byteOffset":0,"componentType":5126,"count":12,"max":[0.1875,0.625],"min":[0.125,0.5625],"name":"tex_coords_gate_C_ZYX","type":"VEC2"},{"bufferView":7,"byteOffset":0,"componentType":5126,"count":12,"max":[0.125,0.5625],"min":[0.0625,0.5],"name":"tex_coords_gate_H_XY","type":"VEC2"},{"bufferView":8,"byteOffset":0,"componentType":5126,"count":12,"max":[0.125,0.5],"min":[0.0625,0.4375],"name":"tex_coords_gate_H","type":"VEC2"},{"bufferView":9,"byteOffset":0,"componentType":5126,"count":12,"max":[0.125,0.4375],"min":[0.0625,0.375],"name":"tex_coords_gate_H_YZ","type":"VEC2"},{"bufferView":10,"byteOffset":0,"componentType":5126,"count":12,"max":[0.1875,0.4375],"min":[0.125,0.375],"name":"tex_coords_gate_SQRT_X","type":"VEC2"},{"bufferView":11,"byteOffset":0,"componentType":5126,"count":12,"max":[0.25,0.4375],"min":[0.1875,0.375],"name":"tex_coords_gate_SQRT_X_DAG","type":"VEC2"},{"bufferView":12,"byteOffset":0,"componentType":5126,"count":12,"max":[0.1875,0.5],"min":[0.125,0.4375],"name":"tex_coords_gate_SQRT_Y","type":"VEC2"},{"bufferView":13,"byteOffset":0,"componentType":5126,"count":12,"max":[0.25,0.5],"min":[0.1875,0.4375],"name":"tex_coords_gate_SQRT_Y_DAG","type":"VEC2"},{"bufferView":14,"byteOffset":0,"componentType":5126,"count":12,"max":[0.1875,0.5625],"min":[0.125,0.5],"name":"tex_coords_gate_S","type":"VEC2"},{"bufferView":15,"byteOffset":0,"componentType":5126,"count":12,"max":[0.25,0.5625],"min":[0.1875,0.5],"name":"tex_coords_gate_S_DAG","type":"VEC2"},{"bufferView":16,"byteOffset":0,"componentType":5126,"count":17,"max":[0,0.400000005960464,0.400000005960464],"min":[0,-0.400000005960464,-0.400000005960464],"name":"circle_loop","type":"VEC3"},{"bufferView":17,"byteOffset":0,"componentType":5126,"count":4,"max":[0,0.45254835486412,0.45254835486412],"min":[0,-0.45254835486412,-0.45254835486412],"name":"control_zswap_line_cross","type":"VEC3"},{"bufferView":18,"byteOffset":0,"componentType":5126,"count":17,"max":[0,0.400000005960464,0.400000005960464],"min":[0,-0.400000005960464,-0.400000005960464],"name":"circle_loop","type":"VEC3"},{"bufferView":19,"byteOffset":0,"componentType":5126,"count":4,"max":[0,0.45254835486412,0.45254835486412],"min":[0,-0.45254835486412,-0.45254835486412],"name":"control_xswap_line_cross","type":"VEC3"},{"bufferView":20,"byteOffset":0,"componentType":5126,"count":12,"max":[0.375,0.625],"min":[0.3125,0.5625],"name":"tex_coords_gate_ISWAP","type":"VEC2"},{"bufferView":21,"byteOffset":0,"componentType":5126,"count":12,"max":[0.4375,0.625],"min":[0.375,0.5625],"name":"tex_coords_gate_ISWAP_DAG","type":"VEC2"},{"bufferView":22,"byteOffset":0,"componentType":5126,"count":12,"max":[0.5,0.625],"min":[0.4375,0.5625],"name":"tex_coords_gate_SWAP","type":"VEC2"},{"bufferView":23,"byteOffset":0,"componentType":5126,"count":12,"max":[0.75,0.4375],"min":[0.6875,0.375],"name":"tex_coords_gate_SQRT_XX","type":"VEC2"},{"bufferView":24,"byteOffset":0,"componentType":5126,"count":12,"max":[0.8125,0.4375],"min":[0.75,0.375],"name":"tex_coords_gate_SQRT_XX_DAG","type":"VEC2"},{"bufferView":25,"byteOffset":0,"componentType":5126,"count":12,"max":[0.75,0.5],"min":[0.6875,0.4375],"name":"tex_coords_gate_SQRT_YY","type":"VEC2"},{"bufferView":26,"byteOffset":0,"componentType":5126,"count":12,"max":[0.8125,0.5],"min":[0.75,0.4375],"name":"tex_coords_gate_SQRT_YY_DAG","type":"VEC2"},{"bufferView":27,"byteOffset":0,"componentType":5126,"count":12,"max":[0.75,0.5625],"min":[0.6875,0.5],"name":"tex_coords_gate_SQRT_ZZ","type":"VEC2"},{"bufferView":28,"byteOffset":0,"componentType":5126,"count":12,"max":[0.8125,0.5625],"min":[0.75,0.5],"name":"tex_coords_gate_SQRT_ZZ_DAG","type":"VEC2"},{"bufferView":29,"byteOffset":0,"componentType":5126,"count":17,"max":[0,0.400000005960464,0.400000005960464],"min":[0,-0.400000005960464,-0.400000005960464],"name":"circle_loop","type":"VEC3"},{"bufferView":30,"byteOffset":0,"componentType":5126,"count":4,"max":[0,0.400000005960464,0.400000005960464],"min":[0,-0.400000005960464,-0.400000005960464],"name":"control_x_line_cross","type":"VEC3"},{"bufferView":31,"byteOffset":0,"componentType":5126,"count":3,"max":[0,0.400000005960464,0.346410155296326],"min":[0,-0.200000032782555,-0.346410185098648],"name":"circle_loop","type":"VEC3"},{"bufferView":32,"byteOffset":0,"componentType":5126,"count":17,"max":[0,0.400000005960464,0.400000005960464],"min":[0,-0.400000005960464,-0.400000005960464],"name":"circle_loop","type":"VEC3"},{"bufferView":33,"byteOffset":0,"componentType":5126,"count":12,"max":[0.5625,0.4375],"min":[0.5,0.375],"name":"tex_coords_gate_E:X","type":"VEC2"},{"bufferView":34,"byteOffset":0,"componentType":5126,"count":12,"max":[0.5625,0.5],"min":[0.5,0.4375],"name":"tex_coords_gate_E:Y","type":"VEC2"},{"bufferView":35,"byteOffset":0,"componentType":5126,"count":12,"max":[0.5625,0.5625],"min":[0.5,0.5],"name":"tex_coords_gate_E:Z","type":"VEC2"},{"bufferView":36,"byteOffset":0,"componentType":5126,"count":12,"max":[0.625,0.4375],"min":[0.5625,0.375],"name":"tex_coords_gate_ELSE_CORRELATED_ERROR:X","type":"VEC2"},{"bufferView":37,"byteOffset":0,"componentType":5126,"count":12,"max":[0.625,0.5],"min":[0.5625,0.4375],"name":"tex_coords_gate_ELSE_CORRELATED_ERROR:Y","type":"VEC2"},{"bufferView":38,"byteOffset":0,"componentType":5126,"count":12,"max":[0.625,0.5625],"min":[0.5625,0.5],"name":"tex_coords_gate_ELSE_CORRELATED_ERROR:Z","type":"VEC2"},{"bufferView":39,"byteOffset":0,"componentType":5126,"count":12,"max":[0.25,0.625],"min":[0.1875,0.5625],"name":"tex_coords_gate_DEPOLARIZE1","type":"VEC2"},{"bufferView":40,"byteOffset":0,"componentType":5126,"count":12,"max":[0.3125,0.625],"min":[0.25,0.5625],"name":"tex_coords_gate_DEPOLARIZE2","type":"VEC2"},{"bufferView":41,"byteOffset":0,"componentType":5126,"count":12,"max":[0.5625,0.625],"min":[0.5,0.5625],"name":"tex_coords_gate_PAULI_CHANNEL_1","type":"VEC2"},{"bufferView":42,"byteOffset":0,"componentType":5126,"count":12,"max":[0.625,0.625],"min":[0.5625,0.5625],"name":"tex_coords_gate_PAULI_CHANNEL_2","type":"VEC2"},{"bufferView":43,"byteOffset":0,"componentType":5126,"count":12,"max":[0.5,0.4375],"min":[0.4375,0.375],"name":"tex_coords_gate_X_ERROR","type":"VEC2"},{"bufferView":44,"byteOffset":0,"componentType":5126,"count":12,"max":[0.5,0.5],"min":[0.4375,0.4375],"name":"tex_coords_gate_Y_ERROR","type":"VEC2"},{"bufferView":45,"byteOffset":0,"componentType":5126,"count":12,"max":[0.5,0.5625],"min":[0.4375,0.5],"name":"tex_coords_gate_Z_ERROR","type":"VEC2"},{"bufferView":46,"byteOffset":0,"componentType":5126,"count":12,"max":[0.9375,0.625],"min":[0.875,0.5625],"name":"tex_coords_gate_HERALDED_ERASE","type":"VEC2"},{"bufferView":47,"byteOffset":0,"componentType":5126,"count":12,"max":[1,0.625],"min":[0.9375,0.5625],"name":"tex_coords_gate_HERALDED_PAULI_CHANNEL_1","type":"VEC2"},{"bufferView":48,"byteOffset":0,"componentType":5126,"count":12,"max":[0.6875,0.4375],"min":[0.625,0.375],"name":"tex_coords_gate_MPP:X","type":"VEC2"},{"bufferView":49,"byteOffset":0,"componentType":5126,"count":12,"max":[0.6875,0.5],"min":[0.625,0.4375],"name":"tex_coords_gate_MPP:Y","type":"VEC2"},{"bufferView":50,"byteOffset":0,"componentType":5126,"count":12,"max":[0.6875,0.5625],"min":[0.625,0.5],"name":"tex_coords_gate_MPP:Z","type":"VEC2"},{"bufferView":51,"byteOffset":0,"componentType":5126,"count":12,"max":[0.4375,0.4375],"min":[0.375,0.375],"name":"tex_coords_gate_MRX","type":"VEC2"},{"bufferView":52,"byteOffset":0,"componentType":5126,"count":12,"max":[0.4375,0.5],"min":[0.375,0.4375],"name":"tex_coords_gate_MRY","type":"VEC2"},{"bufferView":53,"byteOffset":0,"componentType":5126,"count":12,"max":[0.4375,0.5625],"min":[0.375,0.5],"name":"tex_coords_gate_MR","type":"VEC2"},{"bufferView":54,"byteOffset":0,"componentType":5126,"count":12,"max":[0.3125,0.4375],"min":[0.25,0.375],"name":"tex_coords_gate_MX","type":"VEC2"},{"bufferView":55,"byteOffset":0,"componentType":5126,"count":12,"max":[0.3125,0.5],"min":[0.25,0.4375],"name":"tex_coords_gate_MY","type":"VEC2"},{"bufferView":56,"byteOffset":0,"componentType":5126,"count":12,"max":[0.3125,0.5625],"min":[0.25,0.5],"name":"tex_coords_gate_M","type":"VEC2"},{"bufferView":57,"byteOffset":0,"componentType":5126,"count":12,"max":[0.375,0.4375],"min":[0.3125,0.375],"name":"tex_coords_gate_RX","type":"VEC2"},{"bufferView":58,"byteOffset":0,"componentType":5126,"count":12,"max":[0.375,0.5],"min":[0.3125,0.4375],"name":"tex_coords_gate_RY","type":"VEC2"},{"bufferView":59,"byteOffset":0,"componentType":5126,"count":12,"max":[0.375,0.5625],"min":[0.3125,0.5],"name":"tex_coords_gate_R","type":"VEC2"},{"bufferView":60,"byteOffset":0,"componentType":5126,"count":12,"max":[0.6875,0.625],"min":[0.625,0.5625],"name":"tex_coords_gate_MXX","type":"VEC2"},{"bufferView":61,"byteOffset":0,"componentType":5126,"count":12,"max":[0.75,0.625],"min":[0.6875,0.5625],"name":"tex_coords_gate_MYY","type":"VEC2"},{"bufferView":62,"byteOffset":0,"componentType":5126,"count":12,"max":[0.8125,0.625],"min":[0.75,0.5625],"name":"tex_coords_gate_MZZ","type":"VEC2"},{"bufferView":63,"byteOffset":0,"componentType":5126,"count":12,"max":[0.875,0.625],"min":[0.8125,0.5625],"name":"tex_coords_gate_MPAD","type":"VEC2"},{"bufferView":64,"byteOffset":0,"componentType":5126,"count":12,"max":[0.875,0.4375],"min":[0.8125,0.375],"name":"tex_coords_gate_X:REC","type":"VEC2"},{"bufferView":65,"byteOffset":0,"componentType":5126,"count":12,"max":[0.9375,0.5],"min":[0.875,0.4375],"name":"tex_coords_gate_Y:SWEEP","type":"VEC2"},{"bufferView":66,"byteOffset":0,"componentType":5126,"count":12,"max":[0.875,0.5625],"min":[0.8125,0.5],"name":"tex_coords_gate_Z:REC","type":"VEC2"},{"bufferView":67,"byteOffset":0,"componentType":5126,"count":128,"max":[1,-2,-0],"min":[-26,-34,-32],"name":"buf_scattered_lines","type":"VEC3"},{"bufferView":68,"byteOffset":0,"componentType":5126,"count":30,"max":[0,0.5,1],"min":[-17.25,-35,-33],"name":"buf_red_scattered_lines","type":"VEC3"},{"bufferView":69,"byteOffset":0,"componentType":5126,"count":96,"max":[-0.75,-1.20000004768372,0.5],"min":[-23.25,-1.60000002384186,-32.5],"name":"buf_blue_scattered_lines","type":"VEC3"}],"asset":{"version":"2.0"},"bufferViews":[{"buffer":0,"byteLength":144,"byteOffset":0,"name":"cube","target":34962},{"buffer":1,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_I","target":34962},{"buffer":2,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_X","target":34962},{"buffer":3,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_Y","target":34962},{"buffer":4,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_Z","target":34962},{"buffer":5,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_C_XYZ","target":34962},{"buffer":6,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_C_ZYX","target":34962},{"buffer":7,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_H_XY","target":34962},{"buffer":8,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_H","target":34962},{"buffer":9,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_H_YZ","target":34962},{"buffer":10,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_SQRT_X","target":34962},{"buffer":11,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_SQRT_X_DAG","target":34962},{"buffer":12,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_SQRT_Y","target":34962},{"buffer":13,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_SQRT_Y_DAG","target":34962},{"buffer":14,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_S","target":34962},{"buffer":15,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_S_DAG","target":34962},{"buffer":16,"byteLength":204,"byteOffset":0,"name":"circle_loop","target":34962},{"buffer":17,"byteLength":48,"byteOffset":0,"name":"control_zswap_line_cross","target":34962},{"buffer":18,"byteLength":204,"byteOffset":0,"name":"circle_loop","target":34962},{"buffer":19,"byteLength":48,"byteOffset":0,"name":"control_xswap_line_cross","target":34962},{"buffer":20,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_ISWAP","target":34962},{"buffer":21,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_ISWAP_DAG","target":34962},{"buffer":22,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_SWAP","target":34962},{"buffer":23,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_SQRT_XX","target":34962},{"buffer":24,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_SQRT_XX_DAG","target":34962},{"buffer":25,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_SQRT_YY","target":34962},{"buffer":26,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_SQRT_YY_DAG","target":34962},{"buffer":27,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_SQRT_ZZ","target":34962},{"buffer":28,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_SQRT_ZZ_DAG","target":34962},{"buffer":29,"byteLength":204,"byteOffset":0,"name":"circle_loop","target":34962},{"buffer":30,"byteLength":48,"byteOffset":0,"name":"control_x_line_cross","target":34962},{"buffer":31,"byteLength":36,"byteOffset":0,"name":"circle_loop","target":34962},{"buffer":32,"byteLength":204,"byteOffset":0,"name":"circle_loop","target":34962},{"buffer":33,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_E:X","target":34962},{"buffer":34,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_E:Y","target":34962},{"buffer":35,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_E:Z","target":34962},{"buffer":36,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_ELSE_CORRELATED_ERROR:X","target":34962},{"buffer":37,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_ELSE_CORRELATED_ERROR:Y","target":34962},{"buffer":38,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_ELSE_CORRELATED_ERROR:Z","target":34962},{"buffer":39,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_DEPOLARIZE1","target":34962},{"buffer":40,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_DEPOLARIZE2","target":34962},{"buffer":41,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_PAULI_CHANNEL_1","target":34962},{"buffer":42,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_PAULI_CHANNEL_2","target":34962},{"buffer":43,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_X_ERROR","target":34962},{"buffer":44,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_Y_ERROR","target":34962},{"buffer":45,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_Z_ERROR","target":34962},{"buffer":46,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_HERALDED_ERASE","target":34962},{"buffer":47,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_HERALDED_PAULI_CHANNEL_1","target":34962},{"buffer":48,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_MPP:X","target":34962},{"buffer":49,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_MPP:Y","target":34962},{"buffer":50,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_MPP:Z","target":34962},{"buffer":51,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_MRX","target":34962},{"buffer":52,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_MRY","target":34962},{"buffer":53,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_MR","target":34962},{"buffer":54,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_MX","target":34962},{"buffer":55,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_MY","target":34962},{"buffer":56,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_M","target":34962},{"buffer":57,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_RX","target":34962},{"buffer":58,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_RY","target":34962},{"buffer":59,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_R","target":34962},{"buffer":60,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_MXX","target":34962},{"buffer":61,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_MYY","target":34962},{"buffer":62,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_MZZ","target":34962},{"buffer":63,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_MPAD","target":34962},{"buffer":64,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_X:REC","target":34962},{"buffer":65,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_Y:SWEEP","target":34962},{"buffer":66,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_Z:REC","target":34962},{"buffer":67,"byteLength":1536,"byteOffset":0,"name":"buf_scattered_lines","target":34962},{"buffer":68,"byteLength":360,"byteOffset":0,"name":"buf_red_scattered_lines","target":34962},{"buffer":69,"byteLength":1152,"byteOffset":0,"name":"buf_blue_scattered_lines","target":34962}],"buffers":[{"byteLength":144,"name":"cube","uri":"data:application/octet-stream;base64,AAAAAAAAAD8AAAA/AAAAAAAAAD8AAAC/AAAAAAAAAL8AAAA/AAAAAAAAAD8AAAC/AAAAAAAAAL8AAAC/AAAAAAAAAL8AAAA/AAAAAAAAAL8AAAC/AAAAAAAAAD8AAAC/AAAAAAAAAL8AAAA/AAAAAAAAAL8AAAA/AAAAAAAAAD8AAAC/AAAAAAAAAD8AAAA/"},{"byteLength":96,"name":"tex_coords_gate_I","uri":"data:application/octet-stream;base64,AACAPQAAwD4AAAAAAADAPgAAgD0AAOA+AAAAAAAAwD4AAAAAAADgPgAAgD0AAOA+AACAPQAA4D4AAIA9AADAPgAAAAAAAOA+AAAAAAAA4D4AAIA9AADAPgAAAAAAAMA+"},{"byteLength":96,"name":"tex_coords_gate_X","uri":"data:application/octet-stream;base64,AACAPQAAwD4AAAAAAADAPgAAgD0AAOA+AAAAAAAAwD4AAAAAAADgPgAAgD0AAOA+AACAPQAA4D4AAIA9AADAPgAAAAAAAOA+AAAAAAAA4D4AAIA9AADAPgAAAAAAAMA+"},{"byteLength":96,"name":"tex_coords_gate_Y","uri":"data:application/octet-stream;base64,AACAPQAA4D4AAAAAAADgPgAAgD0AAAA/AAAAAAAA4D4AAAAAAAAAPwAAgD0AAAA/AACAPQAAAD8AAIA9AADgPgAAAAAAAAA/AAAAAAAAAD8AAIA9AADgPgAAAAAAAOA+"},{"byteLength":96,"name":"tex_coords_gate_Z","uri":"data:application/octet-stream;base64,AACAPQAAAD8AAAAAAAAAPwAAgD0AABA/AAAAAAAAAD8AAAAAAAAQPwAAgD0AABA/AACAPQAAED8AAIA9AAAAPwAAAAAAABA/AAAAAAAAED8AAIA9AAAAPwAAAAAAAAA/"},{"byteLength":96,"name":"tex_coords_gate_C_XYZ","uri":"data:application/octet-stream;base64,AAAAPgAAED8AAIA9AAAQPwAAAD4AACA/AACAPQAAED8AAIA9AAAgPwAAAD4AACA/AAAAPgAAID8AAAA+AAAQPwAAgD0AACA/AACAPQAAID8AAAA+AAAQPwAAgD0AABA/"},{"byteLength":96,"name":"tex_coords_gate_C_ZYX","uri":"data:application/octet-stream;base64,AABAPgAAED8AAAA+AAAQPwAAQD4AACA/AAAAPgAAED8AAAA+AAAgPwAAQD4AACA/AABAPgAAID8AAEA+AAAQPwAAAD4AACA/AAAAPgAAID8AAEA+AAAQPwAAAD4AABA/"},{"byteLength":96,"name":"tex_coords_gate_H_XY","uri":"data:application/octet-stream;base64,AAAAPgAAAD8AAIA9AAAAPwAAAD4AABA/AACAPQAAAD8AAIA9AAAQPwAAAD4AABA/AAAAPgAAED8AAAA+AAAAPwAAgD0AABA/AACAPQAAED8AAAA+AAAAPwAAgD0AAAA/"},{"byteLength":96,"name":"tex_coords_gate_H","uri":"data:application/octet-stream;base64,AAAAPgAA4D4AAIA9AADgPgAAAD4AAAA/AACAPQAA4D4AAIA9AAAAPwAAAD4AAAA/AAAAPgAAAD8AAAA+AADgPgAAgD0AAAA/AACAPQAAAD8AAAA+AADgPgAAgD0AAOA+"},{"byteLength":96,"name":"tex_coords_gate_H_YZ","uri":"data:application/octet-stream;base64,AAAAPgAAwD4AAIA9AADAPgAAAD4AAOA+AACAPQAAwD4AAIA9AADgPgAAAD4AAOA+AAAAPgAA4D4AAAA+AADAPgAAgD0AAOA+AACAPQAA4D4AAAA+AADAPgAAgD0AAMA+"},{"byteLength":96,"name":"tex_coords_gate_SQRT_X","uri":"data:application/octet-stream;base64,AABAPgAAwD4AAAA+AADAPgAAQD4AAOA+AAAAPgAAwD4AAAA+AADgPgAAQD4AAOA+AABAPgAA4D4AAEA+AADAPgAAAD4AAOA+AAAAPgAA4D4AAEA+AADAPgAAAD4AAMA+"},{"byteLength":96,"name":"tex_coords_gate_SQRT_X_DAG","uri":"data:application/octet-stream;base64,AACAPgAAwD4AAEA+AADAPgAAgD4AAOA+AABAPgAAwD4AAEA+AADgPgAAgD4AAOA+AACAPgAA4D4AAIA+AADAPgAAQD4AAOA+AABAPgAA4D4AAIA+AADAPgAAQD4AAMA+"},{"byteLength":96,"name":"tex_coords_gate_SQRT_Y","uri":"data:application/octet-stream;base64,AABAPgAA4D4AAAA+AADgPgAAQD4AAAA/AAAAPgAA4D4AAAA+AAAAPwAAQD4AAAA/AABAPgAAAD8AAEA+AADgPgAAAD4AAAA/AAAAPgAAAD8AAEA+AADgPgAAAD4AAOA+"},{"byteLength":96,"name":"tex_coords_gate_SQRT_Y_DAG","uri":"data:application/octet-stream;base64,AACAPgAA4D4AAEA+AADgPgAAgD4AAAA/AABAPgAA4D4AAEA+AAAAPwAAgD4AAAA/AACAPgAAAD8AAIA+AADgPgAAQD4AAAA/AABAPgAAAD8AAIA+AADgPgAAQD4AAOA+"},{"byteLength":96,"name":"tex_coords_gate_S","uri":"data:application/octet-stream;base64,AABAPgAAAD8AAAA+AAAAPwAAQD4AABA/AAAAPgAAAD8AAAA+AAAQPwAAQD4AABA/AABAPgAAED8AAEA+AAAAPwAAAD4AABA/AAAAPgAAED8AAEA+AAAAPwAAAD4AAAA/"},{"byteLength":96,"name":"tex_coords_gate_S_DAG","uri":"data:application/octet-stream;base64,AACAPgAAAD8AAEA+AAAAPwAAgD4AABA/AABAPgAAAD8AAEA+AAAQPwAAgD4AABA/AACAPgAAED8AAIA+AAAAPwAAQD4AABA/AABAPgAAED8AAIA+AAAAPwAAQD4AAAA/"},{"byteLength":204,"name":"circle_loop","uri":"data:application/octet-stream;base64,AAAAAM3MzD4AAAAAAAAAAOU1vT5Fvxw+AAAAAMPQkD7D0JA+AAAAAES/HD7lNb0+AAAAAPIwlrLNzMw+AAAAAEe/HL7lNb0+AAAAAMPQkL7D0JA+AAAAAOc1vb5Avxw+AAAAAM3MzL7yMBazAAAAAOU1vb5Evxy+AAAAAMHQkL7E0JC+AAAAADy/HL7nNb2+AAAAAPLkozHNzMy+AAAAAEm/HD7kNb2+AAAAAMbQkD6/0JC+AAAAAOY1vT5Evxy+AAAAAM3MzD4AAAAA"},{"byteLength":48,"name":"control_zswap_line_cross","uri":"data:application/octet-stream;base64,AAAAAGu0575rtOe+AAAAAGu05z5rtOc+AAAAAGu0575rtOc+AAAAAGu05z5rtOe+"},{"byteLength":204,"name":"circle_loop","uri":"data:application/octet-stream;base64,AAAAAM3MzD4AAAAAAAAAAOU1vT5Fvxw+AAAAAMPQkD7D0JA+AAAAAES/HD7lNb0+AAAAAPIwlrLNzMw+AAAAAEe/HL7lNb0+AAAAAMPQkL7D0JA+AAAAAOc1vb5Avxw+AAAAAM3MzL7yMBazAAAAAOU1vb5Evxy+AAAAAMHQkL7E0JC+AAAAADy/HL7nNb2+AAAAAPLkozHNzMy+AAAAAEm/HD7kNb2+AAAAAMbQkD6/0JC+AAAAAOY1vT5Evxy+AAAAAM3MzD4AAAAA"},{"byteLength":48,"name":"control_xswap_line_cross","uri":"data:application/octet-stream;base64,AAAAAGu0575rtOe+AAAAAGu05z5rtOc+AAAAAGu0575rtOc+AAAAAGu05z5rtOe+"},{"byteLength":96,"name":"tex_coords_gate_ISWAP","uri":"data:application/octet-stream;base64,AADAPgAAED8AAKA+AAAQPwAAwD4AACA/AACgPgAAED8AAKA+AAAgPwAAwD4AACA/AADAPgAAID8AAMA+AAAQPwAAoD4AACA/AACgPgAAID8AAMA+AAAQPwAAoD4AABA/"},{"byteLength":96,"name":"tex_coords_gate_ISWAP_DAG","uri":"data:application/octet-stream;base64,AADgPgAAED8AAMA+AAAQPwAA4D4AACA/AADAPgAAED8AAMA+AAAgPwAA4D4AACA/AADgPgAAID8AAOA+AAAQPwAAwD4AACA/AADAPgAAID8AAOA+AAAQPwAAwD4AABA/"},{"byteLength":96,"name":"tex_coords_gate_SWAP","uri":"data:application/octet-stream;base64,AAAAPwAAED8AAOA+AAAQPwAAAD8AACA/AADgPgAAED8AAOA+AAAgPwAAAD8AACA/AAAAPwAAID8AAAA/AAAQPwAA4D4AACA/AADgPgAAID8AAAA/AAAQPwAA4D4AABA/"},{"byteLength":96,"name":"tex_coords_gate_SQRT_XX","uri":"data:application/octet-stream;base64,AABAPwAAwD4AADA/AADAPgAAQD8AAOA+AAAwPwAAwD4AADA/AADgPgAAQD8AAOA+AABAPwAA4D4AAEA/AADAPgAAMD8AAOA+AAAwPwAA4D4AAEA/AADAPgAAMD8AAMA+"},{"byteLength":96,"name":"tex_coords_gate_SQRT_XX_DAG","uri":"data:application/octet-stream;base64,AABQPwAAwD4AAEA/AADAPgAAUD8AAOA+AABAPwAAwD4AAEA/AADgPgAAUD8AAOA+AABQPwAA4D4AAFA/AADAPgAAQD8AAOA+AABAPwAA4D4AAFA/AADAPgAAQD8AAMA+"},{"byteLength":96,"name":"tex_coords_gate_SQRT_YY","uri":"data:application/octet-stream;base64,AABAPwAA4D4AADA/AADgPgAAQD8AAAA/AAAwPwAA4D4AADA/AAAAPwAAQD8AAAA/AABAPwAAAD8AAEA/AADgPgAAMD8AAAA/AAAwPwAAAD8AAEA/AADgPgAAMD8AAOA+"},{"byteLength":96,"name":"tex_coords_gate_SQRT_YY_DAG","uri":"data:application/octet-stream;base64,AABQPwAA4D4AAEA/AADgPgAAUD8AAAA/AABAPwAA4D4AAEA/AAAAPwAAUD8AAAA/AABQPwAAAD8AAFA/AADgPgAAQD8AAAA/AABAPwAAAD8AAFA/AADgPgAAQD8AAOA+"},{"byteLength":96,"name":"tex_coords_gate_SQRT_ZZ","uri":"data:application/octet-stream;base64,AABAPwAAAD8AADA/AAAAPwAAQD8AABA/AAAwPwAAAD8AADA/AAAQPwAAQD8AABA/AABAPwAAED8AAEA/AAAAPwAAMD8AABA/AAAwPwAAED8AAEA/AAAAPwAAMD8AAAA/"},{"byteLength":96,"name":"tex_coords_gate_SQRT_ZZ_DAG","uri":"data:application/octet-stream;base64,AABQPwAAAD8AAEA/AAAAPwAAUD8AABA/AABAPwAAAD8AAEA/AAAQPwAAUD8AABA/AABQPwAAED8AAFA/AAAAPwAAQD8AABA/AABAPwAAED8AAFA/AAAAPwAAQD8AAAA/"},{"byteLength":204,"name":"circle_loop","uri":"data:application/octet-stream;base64,AAAAAM3MzD4AAAAAAAAAAOU1vT5Fvxw+AAAAAMPQkD7D0JA+AAAAAES/HD7lNb0+AAAAAPIwlrLNzMw+AAAAAEe/HL7lNb0+AAAAAMPQkL7D0JA+AAAAAOc1vb5Avxw+AAAAAM3MzL7yMBazAAAAAOU1vb5Evxy+AAAAAMHQkL7E0JC+AAAAADy/HL7nNb2+AAAAAPLkozHNzMy+AAAAAEm/HD7kNb2+AAAAAMbQkD6/0JC+AAAAAOY1vT5Evxy+AAAAAM3MzD4AAAAA"},{"byteLength":48,"name":"control_x_line_cross","uri":"data:application/octet-stream;base64,AAAAAM3MzL4AAAAAAAAAAM3MzD4AAAAAAAAAAAAAAADNzMy+AAAAAAAAAADNzMw+"},{"byteLength":36,"name":"circle_loop","uri":"data:application/octet-stream;base64,AAAAAM3MzD4AAAAAAAAAAM/MTL6sXLE+AAAAAMvMTL6tXLG+"},{"byteLength":204,"name":"circle_loop","uri":"data:application/octet-stream;base64,AAAAAM3MzD4AAAAAAAAAAOU1vT5Fvxw+AAAAAMPQkD7D0JA+AAAAAES/HD7lNb0+AAAAAPIwlrLNzMw+AAAAAEe/HL7lNb0+AAAAAMPQkL7D0JA+AAAAAOc1vb5Avxw+AAAAAM3MzL7yMBazAAAAAOU1vb5Evxy+AAAAAMHQkL7E0JC+AAAAADy/HL7nNb2+AAAAAPLkozHNzMy+AAAAAEm/HD7kNb2+AAAAAMbQkD6/0JC+AAAAAOY1vT5Evxy+AAAAAM3MzD4AAAAA"},{"byteLength":96,"name":"tex_coords_gate_E:X","uri":"data:application/octet-stream;base64,AAAQPwAAwD4AAAA/AADAPgAAED8AAOA+AAAAPwAAwD4AAAA/AADgPgAAED8AAOA+AAAQPwAA4D4AABA/AADAPgAAAD8AAOA+AAAAPwAA4D4AABA/AADAPgAAAD8AAMA+"},{"byteLength":96,"name":"tex_coords_gate_E:Y","uri":"data:application/octet-stream;base64,AAAQPwAA4D4AAAA/AADgPgAAED8AAAA/AAAAPwAA4D4AAAA/AAAAPwAAED8AAAA/AAAQPwAAAD8AABA/AADgPgAAAD8AAAA/AAAAPwAAAD8AABA/AADgPgAAAD8AAOA+"},{"byteLength":96,"name":"tex_coords_gate_E:Z","uri":"data:application/octet-stream;base64,AAAQPwAAAD8AAAA/AAAAPwAAED8AABA/AAAAPwAAAD8AAAA/AAAQPwAAED8AABA/AAAQPwAAED8AABA/AAAAPwAAAD8AABA/AAAAPwAAED8AABA/AAAAPwAAAD8AAAA/"},{"byteLength":96,"name":"tex_coords_gate_ELSE_CORRELATED_ERROR:X","uri":"data:application/octet-stream;base64,AAAgPwAAwD4AABA/AADAPgAAID8AAOA+AAAQPwAAwD4AABA/AADgPgAAID8AAOA+AAAgPwAA4D4AACA/AADAPgAAED8AAOA+AAAQPwAA4D4AACA/AADAPgAAED8AAMA+"},{"byteLength":96,"name":"tex_coords_gate_ELSE_CORRELATED_ERROR:Y","uri":"data:application/octet-stream;base64,AAAgPwAA4D4AABA/AADgPgAAID8AAAA/AAAQPwAA4D4AABA/AAAAPwAAID8AAAA/AAAgPwAAAD8AACA/AADgPgAAED8AAAA/AAAQPwAAAD8AACA/AADgPgAAED8AAOA+"},{"byteLength":96,"name":"tex_coords_gate_ELSE_CORRELATED_ERROR:Z","uri":"data:application/octet-stream;base64,AAAgPwAAAD8AABA/AAAAPwAAID8AABA/AAAQPwAAAD8AABA/AAAQPwAAID8AABA/AAAgPwAAED8AACA/AAAAPwAAED8AABA/AAAQPwAAED8AACA/AAAAPwAAED8AAAA/"},{"byteLength":96,"name":"tex_coords_gate_DEPOLARIZE1","uri":"data:application/octet-stream;base64,AACAPgAAED8AAEA+AAAQPwAAgD4AACA/AABAPgAAED8AAEA+AAAgPwAAgD4AACA/AACAPgAAID8AAIA+AAAQPwAAQD4AACA/AABAPgAAID8AAIA+AAAQPwAAQD4AABA/"},{"byteLength":96,"name":"tex_coords_gate_DEPOLARIZE2","uri":"data:application/octet-stream;base64,AACgPgAAED8AAIA+AAAQPwAAoD4AACA/AACAPgAAED8AAIA+AAAgPwAAoD4AACA/AACgPgAAID8AAKA+AAAQPwAAgD4AACA/AACAPgAAID8AAKA+AAAQPwAAgD4AABA/"},{"byteLength":96,"name":"tex_coords_gate_PAULI_CHANNEL_1","uri":"data:application/octet-stream;base64,AAAQPwAAED8AAAA/AAAQPwAAED8AACA/AAAAPwAAED8AAAA/AAAgPwAAED8AACA/AAAQPwAAID8AABA/AAAQPwAAAD8AACA/AAAAPwAAID8AABA/AAAQPwAAAD8AABA/"},{"byteLength":96,"name":"tex_coords_gate_PAULI_CHANNEL_2","uri":"data:application/octet-stream;base64,AAAgPwAAED8AABA/AAAQPwAAID8AACA/AAAQPwAAED8AABA/AAAgPwAAID8AACA/AAAgPwAAID8AACA/AAAQPwAAED8AACA/AAAQPwAAID8AACA/AAAQPwAAED8AABA/"},{"byteLength":96,"name":"tex_coords_gate_X_ERROR","uri":"data:application/octet-stream;base64,AAAAPwAAwD4AAOA+AADAPgAAAD8AAOA+AADgPgAAwD4AAOA+AADgPgAAAD8AAOA+AAAAPwAA4D4AAAA/AADAPgAA4D4AAOA+AADgPgAA4D4AAAA/AADAPgAA4D4AAMA+"},{"byteLength":96,"name":"tex_coords_gate_Y_ERROR","uri":"data:application/octet-stream;base64,AAAAPwAA4D4AAOA+AADgPgAAAD8AAAA/AADgPgAA4D4AAOA+AAAAPwAAAD8AAAA/AAAAPwAAAD8AAAA/AADgPgAA4D4AAAA/AADgPgAAAD8AAAA/AADgPgAA4D4AAOA+"},{"byteLength":96,"name":"tex_coords_gate_Z_ERROR","uri":"data:application/octet-stream;base64,AAAAPwAAAD8AAOA+AAAAPwAAAD8AABA/AADgPgAAAD8AAOA+AAAQPwAAAD8AABA/AAAAPwAAED8AAAA/AAAAPwAA4D4AABA/AADgPgAAED8AAAA/AAAAPwAA4D4AAAA/"},{"byteLength":96,"name":"tex_coords_gate_HERALDED_ERASE","uri":"data:application/octet-stream;base64,AABwPwAAED8AAGA/AAAQPwAAcD8AACA/AABgPwAAED8AAGA/AAAgPwAAcD8AACA/AABwPwAAID8AAHA/AAAQPwAAYD8AACA/AABgPwAAID8AAHA/AAAQPwAAYD8AABA/"},{"byteLength":96,"name":"tex_coords_gate_HERALDED_PAULI_CHANNEL_1","uri":"data:application/octet-stream;base64,AACAPwAAED8AAHA/AAAQPwAAgD8AACA/AABwPwAAED8AAHA/AAAgPwAAgD8AACA/AACAPwAAID8AAIA/AAAQPwAAcD8AACA/AABwPwAAID8AAIA/AAAQPwAAcD8AABA/"},{"byteLength":96,"name":"tex_coords_gate_MPP:X","uri":"data:application/octet-stream;base64,AAAwPwAAwD4AACA/AADAPgAAMD8AAOA+AAAgPwAAwD4AACA/AADgPgAAMD8AAOA+AAAwPwAA4D4AADA/AADAPgAAID8AAOA+AAAgPwAA4D4AADA/AADAPgAAID8AAMA+"},{"byteLength":96,"name":"tex_coords_gate_MPP:Y","uri":"data:application/octet-stream;base64,AAAwPwAA4D4AACA/AADgPgAAMD8AAAA/AAAgPwAA4D4AACA/AAAAPwAAMD8AAAA/AAAwPwAAAD8AADA/AADgPgAAID8AAAA/AAAgPwAAAD8AADA/AADgPgAAID8AAOA+"},{"byteLength":96,"name":"tex_coords_gate_MPP:Z","uri":"data:application/octet-stream;base64,AAAwPwAAAD8AACA/AAAAPwAAMD8AABA/AAAgPwAAAD8AACA/AAAQPwAAMD8AABA/AAAwPwAAED8AADA/AAAAPwAAID8AABA/AAAgPwAAED8AADA/AAAAPwAAID8AAAA/"},{"byteLength":96,"name":"tex_coords_gate_MRX","uri":"data:application/octet-stream;base64,AADgPgAAwD4AAMA+AADAPgAA4D4AAOA+AADAPgAAwD4AAMA+AADgPgAA4D4AAOA+AADgPgAA4D4AAOA+AADAPgAAwD4AAOA+AADAPgAA4D4AAOA+AADAPgAAwD4AAMA+"},{"byteLength":96,"name":"tex_coords_gate_MRY","uri":"data:application/octet-stream;base64,AADgPgAA4D4AAMA+AADgPgAA4D4AAAA/AADAPgAA4D4AAMA+AAAAPwAA4D4AAAA/AADgPgAAAD8AAOA+AADgPgAAwD4AAAA/AADAPgAAAD8AAOA+AADgPgAAwD4AAOA+"},{"byteLength":96,"name":"tex_coords_gate_MR","uri":"data:application/octet-stream;base64,AADgPgAAAD8AAMA+AAAAPwAA4D4AABA/AADAPgAAAD8AAMA+AAAQPwAA4D4AABA/AADgPgAAED8AAOA+AAAAPwAAwD4AABA/AADAPgAAED8AAOA+AAAAPwAAwD4AAAA/"},{"byteLength":96,"name":"tex_coords_gate_MX","uri":"data:application/octet-stream;base64,AACgPgAAwD4AAIA+AADAPgAAoD4AAOA+AACAPgAAwD4AAIA+AADgPgAAoD4AAOA+AACgPgAA4D4AAKA+AADAPgAAgD4AAOA+AACAPgAA4D4AAKA+AADAPgAAgD4AAMA+"},{"byteLength":96,"name":"tex_coords_gate_MY","uri":"data:application/octet-stream;base64,AACgPgAA4D4AAIA+AADgPgAAoD4AAAA/AACAPgAA4D4AAIA+AAAAPwAAoD4AAAA/AACgPgAAAD8AAKA+AADgPgAAgD4AAAA/AACAPgAAAD8AAKA+AADgPgAAgD4AAOA+"},{"byteLength":96,"name":"tex_coords_gate_M","uri":"data:application/octet-stream;base64,AACgPgAAAD8AAIA+AAAAPwAAoD4AABA/AACAPgAAAD8AAIA+AAAQPwAAoD4AABA/AACgPgAAED8AAKA+AAAAPwAAgD4AABA/AACAPgAAED8AAKA+AAAAPwAAgD4AAAA/"},{"byteLength":96,"name":"tex_coords_gate_RX","uri":"data:application/octet-stream;base64,AADAPgAAwD4AAKA+AADAPgAAwD4AAOA+AACgPgAAwD4AAKA+AADgPgAAwD4AAOA+AADAPgAA4D4AAMA+AADAPgAAoD4AAOA+AACgPgAA4D4AAMA+AADAPgAAoD4AAMA+"},{"byteLength":96,"name":"tex_coords_gate_RY","uri":"data:application/octet-stream;base64,AADAPgAA4D4AAKA+AADgPgAAwD4AAAA/AACgPgAA4D4AAKA+AAAAPwAAwD4AAAA/AADAPgAAAD8AAMA+AADgPgAAoD4AAAA/AACgPgAAAD8AAMA+AADgPgAAoD4AAOA+"},{"byteLength":96,"name":"tex_coords_gate_R","uri":"data:application/octet-stream;base64,AADAPgAAAD8AAKA+AAAAPwAAwD4AABA/AACgPgAAAD8AAKA+AAAQPwAAwD4AABA/AADAPgAAED8AAMA+AAAAPwAAoD4AABA/AACgPgAAED8AAMA+AAAAPwAAoD4AAAA/"},{"byteLength":96,"name":"tex_coords_gate_MXX","uri":"data:application/octet-stream;base64,AAAwPwAAED8AACA/AAAQPwAAMD8AACA/AAAgPwAAED8AACA/AAAgPwAAMD8AACA/AAAwPwAAID8AADA/AAAQPwAAID8AACA/AAAgPwAAID8AADA/AAAQPwAAID8AABA/"},{"byteLength":96,"name":"tex_coords_gate_MYY","uri":"data:application/octet-stream;base64,AABAPwAAED8AADA/AAAQPwAAQD8AACA/AAAwPwAAED8AADA/AAAgPwAAQD8AACA/AABAPwAAID8AAEA/AAAQPwAAMD8AACA/AAAwPwAAID8AAEA/AAAQPwAAMD8AABA/"},{"byteLength":96,"name":"tex_coords_gate_MZZ","uri":"data:application/octet-stream;base64,AABQPwAAED8AAEA/AAAQPwAAUD8AACA/AABAPwAAED8AAEA/AAAgPwAAUD8AACA/AABQPwAAID8AAFA/AAAQPwAAQD8AACA/AABAPwAAID8AAFA/AAAQPwAAQD8AABA/"},{"byteLength":96,"name":"tex_coords_gate_MPAD","uri":"data:application/octet-stream;base64,AABgPwAAED8AAFA/AAAQPwAAYD8AACA/AABQPwAAED8AAFA/AAAgPwAAYD8AACA/AABgPwAAID8AAGA/AAAQPwAAUD8AACA/AABQPwAAID8AAGA/AAAQPwAAUD8AABA/"},{"byteLength":96,"name":"tex_coords_gate_X:REC","uri":"data:application/octet-stream;base64,AABgPwAAwD4AAFA/AADAPgAAYD8AAOA+AABQPwAAwD4AAFA/AADgPgAAYD8AAOA+AABgPwAA4D4AAGA/AADAPgAAUD8AAOA+AABQPwAA4D4AAGA/AADAPgAAUD8AAMA+"},{"byteLength":96,"name":"tex_coords_gate_Y:SWEEP","uri":"data:application/octet-stream;base64,AABwPwAA4D4AAGA/AADgPgAAcD8AAAA/AABgPwAA4D4AAGA/AAAAPwAAcD8AAAA/AABwPwAAAD8AAHA/AADgPgAAYD8AAAA/AABgPwAAAD8AAHA/AADgPgAAYD8AAOA+"},{"byteLength":96,"name":"tex_coords_gate_Z:REC","uri":"data:application/octet-stream;base64,AABgPwAAAD8AAFA/AAAAPwAAYD8AABA/AABQPwAAAD8AAFA/AAAQPwAAYD8AABA/AABgPwAAED8AAGA/AAAAPwAAUD8AABA/AABQPwAAED8AAGA/AAAAPwAAUD8AAAA/"},{"byteLength":1536,"name":"buf_scattered_lines","uri":"data:application/octet-stream;base64,AABAwAAAAMIAAADCAABQwAAAiMEAAIDBAABQwAAAiMEAAIDBAABAwAAAAMAAAACAAABAwAAAgMAAAACAAABAwAAAwMAAAACAAABAwAAAAMEAAACAAABAwAAAIMEAAACAAABAwAAAQMEAAACAAABAwAAAYMEAAACAAABAwAAAgMEAAACAAABAwAAAkMEAAACAAACAwAAAAMIAAADCAACIwAAAiMEAAIDBAACIwAAAiMEAAIDBAACAwAAAAMAAAACAAACAwAAAgMAAAACAAACAwAAAwMAAAACAAACAwAAAAMEAAACAAACAwAAAIMEAAACAAACAwAAAQMEAAACAAACAwAAAYMEAAACAAACAwAAAgMEAAACAAACAwAAAkMEAAACAAACAwAAAoMEAAACAAACAwAAAsMEAAACAAACgwAAAAMIAAADCAACowAAAiMEAAIDBAACowAAAiMEAAIDBAACgwAAAAMAAAACAAACgwAAAgMAAAACAAACgwAAAwMAAAACAAACgwAAAAMEAAACAAACgwAAAIMEAAACAAACgwAAAQMEAAACAAACgwAAAYMEAAACAAACgwAAAgMEAAACAAACgwAAAkMEAAACAAACgwAAAoMEAAACAAACgwAAAsMEAAACAAACgwAAAwMEAAACAAACgwAAA0MEAAACAAACgwAAA4MEAAACAAACgwAAA8MEAAACAAACgwAAAAMIAAACAAACgwAAACMIAAACAAADAwAAAgMAAAACAAADAwAAAAMAAAACAAADAwAAAwMAAAACAAADAwAAAgMAAAACAAADAwAAAYMEAAACAAADIwAAAMMEAAACAAADIwAAAMMEAAACAAADAwAAAAMEAAACAAADAwAAAQMEAAACAAADAwAAAYMEAAACAAADgwAAAAMAAAACAAADgwAAAgMAAAACAAADgwAAAAMEAAACAAADgwAAAIMEAAACAAAAQwQAAAMAAAACAAAAUwQAAiMEAAIDBAAAUwQAAiMEAAIDBAAAQwQAAAMIAAADCAAAQwQAAgMAAAACAAAAQwQAAAMAAAACAAAAgwQAAAMAAAACAAAAkwQAAiMEAAIDBAAAkwQAAiMEAAIDBAAAgwQAAAMIAAADCAABAwQAAAMIAAADCAABEwQAAiMEAAIDBAABEwQAAiMEAAIDBAABAwQAAAMAAAACAAABAwQAAgMAAAACAAABAwQAAwMAAAACAAABAwQAAAMEAAACAAABAwQAAIMEAAACAAABAwQAAQMEAAACAAABAwQAAYMEAAACAAABwwQAAAMIAAADCAAB0wQAAiMEAAIDBAAB0wQAAiMEAAIDBAABwwQAAAMAAAACAAADAwQAAgMAAAACAAADAwQAAwMAAAACAAADAwQAAAMEAAACAAADAwQAAIMEAAACAAADAwQAAYMEAAACAAADAwQAAQMEAAACAAADAwQAAgMEAAACAAADAwQAAYMEAAACAAACAPwAAAMIAAADCAADQwQAAAMIAAADCAACAPwAAAMAAAACAAADQwQAAAMAAAACAAACAPwAAgMAAAACAAADQwQAAgMAAAACAAACAPwAAwMAAAACAAADQwQAAwMAAAACAAACAPwAAAMEAAACAAADQwQAAAMEAAACAAACAPwAAIMEAAACAAADQwQAAIMEAAACAAACAPwAAQMEAAACAAADQwQAAQMEAAACAAACAPwAAYMEAAACAAADQwQAAYMEAAACAAACAPwAAgMEAAACAAADQwQAAgMEAAACAAACAPwAAkMEAAACAAADQwQAAkMEAAACAAACAPwAAoMEAAACAAADQwQAAoMEAAACAAACAPwAAsMEAAACAAADQwQAAsMEAAACAAACAPwAAwMEAAACAAADQwQAAwMEAAACAAACAPwAA0MEAAACAAADQwQAA0MEAAACAAACAPwAA4MEAAACAAADQwQAA4MEAAACAAACAPwAA8MEAAACAAADQwQAA8MEAAACAAACAPwAAAMIAAACAAADQwQAAAMIAAACAAACAPwAACMIAAACAAADQwQAACMIAAACA"},{"byteLength":360,"name":"buf_red_scattered_lines","uri":"data:application/octet-stream;base64,AAAAAAAAAIAAAIDBAABAwAAAAIAAAIDBAAAgwAAAAL8AAIDBAABAwAAAAIAAAIDBAAAgwAAAAD8AAIDBAABAwAAAAIAAAIDBAABcwQAAgL8AAIA/AABcwQAAgL8AAATCAABcwQAAgL8AAIA/AABcwQAADMIAAIA/AABcwQAAgL8AAIA/AACKwQAAgL8AAIA/AABcwQAAgL8AAATCAABcwQAADMIAAATCAABcwQAAgL8AAATCAACKwQAAgL8AAATCAABcwQAADMIAAIA/AABcwQAADMIAAATCAABcwQAADMIAAIA/AACKwQAADMIAAIA/AABcwQAADMIAAATCAACKwQAADMIAAATCAACKwQAAgL8AAIA/AACKwQAAgL8AAATCAACKwQAAgL8AAIA/AACKwQAADMIAAIA/AACKwQAAgL8AAATCAACKwQAADMIAAATCAACKwQAADMIAAIA/AACKwQAADMIAAATC"},{"byteLength":1152,"name":"buf_blue_scattered_lines","uri":"data:application/octet-stream;base64,AABAv83MzL8AAAA/AABAv5qZmb8AAAA/AABAv83MzL8AAALCAABAv5qZmb8AAALCAABAv5qZmb8AAAA/AABAv5qZmb8AAALCAABAv5qZmb8AAAA/AAAQwJqZmb8AAAA/AABAv5qZmb8AAALCAAAQwJqZmb8AAALCAAAQwM3MzL8AAAA/AAAQwJqZmb8AAAA/AAAQwM3MzL8AAALCAAAQwJqZmb8AAALCAAAQwJqZmb8AAAA/AAAQwJqZmb8AAALCAAAwwM3MzL8AAAA/AAAwwJqZmb8AAAA/AAAwwM3MzL8AAALCAAAwwJqZmb8AAALCAAAwwJqZmb8AAAA/AAAwwJqZmb8AAALCAAAwwJqZmb8AAAA/AACowJqZmb8AAAA/AAAwwJqZmb8AAALCAACowJqZmb8AAALCAACowM3MzL8AAAA/AACowJqZmb8AAAA/AACowM3MzL8AAALCAACowJqZmb8AAALCAACowJqZmb8AAAA/AACowJqZmb8AAALCAAC4wM3MzL8AAAA/AAC4wJqZmb8AAAA/AAC4wM3MzL8AAALCAAC4wJqZmb8AAALCAAC4wJqZmb8AAAA/AAC4wJqZmb8AAALCAAC4wJqZmb8AAAA/AAAEwZqZmb8AAAA/AAC4wJqZmb8AAALCAAAEwZqZmb8AAALCAAAEwc3MzL8AAAA/AAAEwZqZmb8AAAA/AAAEwc3MzL8AAALCAAAEwZqZmb8AAALCAAAEwZqZmb8AAAA/AAAEwZqZmb8AAALCAAAMwc3MzL8AAAA/AAAMwZqZmb8AAAA/AAAMwc3MzL8AAALCAAAMwZqZmb8AAALCAAAMwZqZmb8AAAA/AAAMwZqZmb8AAALCAAAMwZqZmb8AAAA/AAA0wZqZmb8AAAA/AAAMwZqZmb8AAALCAAA0wZqZmb8AAALCAAA0wc3MzL8AAAA/AAA0wZqZmb8AAAA/AAA0wc3MzL8AAALCAAA0wZqZmb8AAALCAAA0wZqZmb8AAAA/AAA0wZqZmb8AAALCAABcwc3MzL8AAAA/AABcwZqZmb8AAAA/AABcwc3MzL8AAALCAABcwZqZmb8AAALCAABcwZqZmb8AAAA/AABcwZqZmb8AAALCAABcwZqZmb8AAAA/AACCwZqZmb8AAAA/AABcwZqZmb8AAALCAACCwZqZmb8AAALCAACCwc3MzL8AAAA/AACCwZqZmb8AAAA/AACCwc3MzL8AAALCAACCwZqZmb8AAALCAACCwZqZmb8AAAA/AACCwZqZmb8AAALCAACWwc3MzL8AAAA/AACWwZqZmb8AAAA/AACWwc3MzL8AAALCAACWwZqZmb8AAALCAACWwZqZmb8AAAA/AACWwZqZmb8AAALCAACWwZqZmb8AAAA/AAC6wZqZmb8AAAA/AACWwZqZmb8AAALCAAC6wZqZmb8AAALCAAC6wc3MzL8AAAA/AAC6wZqZmb8AAAA/AAC6wc3MzL8AAALCAAC6wZqZmb8AAALCAAC6wZqZmb8AAAA/AAC6wZqZmb8AAALC"}],"images":[{"name":"gates_image","uri":"data:image/png;base64,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"}],"materials":[{"doubleSided":false,"name":"gates_material","pbrMetallicRoughness":{"baseColorFactor":[1,1,1,1],"baseColorTexture":{"index":0,"texCoord":0},"metallicFactor":0.4,"roughnessFactor":0.5}},{"doubleSided":true,"name":"black","pbrMetallicRoughness":{"baseColorFactor":[0,0,0,1],"metallicFactor":1,"roughnessFactor":1}},{"doubleSided":true,"name":"white","pbrMetallicRoughness":{"baseColorFactor":[1,1,1,1],"metallicFactor":0.4,"roughnessFactor":0.5}},{"doubleSided":true,"name":"white","pbrMetallicRoughness":{"baseColorFactor":[1,1,1,1],"metallicFactor":0.4,"roughnessFactor":0.5}},{"doubleSided":true,"name":"black","pbrMetallicRoughness":{"baseColorFactor":[0,0,0,1],"metallicFactor":1,"roughnessFactor":1}},{"doubleSided":true,"name":"white","pbrMetallicRoughness":{"baseColorFactor":[1,1,1,1],"metallicFactor":0.4,"roughnessFactor":0.5}},{"doubleSided":true,"name":"black","pbrMetallicRoughness":{"baseColorFactor":[0,0,0,1],"metallicFactor":1,"roughnessFactor":1}},{"doubleSided":true,"name":"black","pbrMetallicRoughness":{"baseColorFactor":[0,0,0,1],"metallicFactor":1,"roughnessFactor":1}},{"doubleSided":true,"name":"gray","pbrMetallicRoughness":{"baseColorFactor":[0.5,0.5,0.5,1],"metallicFactor":1,"roughnessFactor":1}},{"doubleSided":true,"name":"black","pbrMetallicRoughness":{"baseColorFactor":[0,0,0,1],"metallicFactor":1,"roughnessFactor":1}},{"doubleSided":true,"name":"black","pbrMetallicRoughness":{"baseColorFactor":[0,0,0,1],"metallicFactor":1,"roughnessFactor":1}},{"doubleSided":true,"name":"red","pbrMetallicRoughness":{"baseColorFactor":[1,0,0,1],"metallicFactor":1,"roughnessFactor":1}},{"doubleSided":true,"name":"blue","pbrMetallicRoughness":{"baseColorFactor":[0,0,1,1],"metallicFactor":1,"roughnessFactor":1}}],"meshes":[{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":1},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":2},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":3},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":4},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":5},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":6},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":7},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":8},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":9},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":10},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":11},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":12},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":13},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":14},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":15},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":16},"material":1,"mode":6},{"attributes":{"POSITION":17},"material":2,"mode":1}]},{"primitives":[{"attributes":{"POSITION":18},"material":3,"mode":6},{"attributes":{"POSITION":18},"material":4,"mode":3},{"attributes":{"POSITION":19},"material":4,"mode":1}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":20},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":21},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":22},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":23},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":24},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":25},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":26},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":27},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":28},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":29},"material":5,"mode":6},{"attributes":{"POSITION":29},"material":6,"mode":3},{"attributes":{"POSITION":30},"material":6,"mode":1}]},{"primitives":[{"attributes":{"POSITION":31},"material":7,"mode":2},{"attributes":{"POSITION":31},"material":8,"mode":4}]},{"primitives":[{"attributes":{"POSITION":32},"material":9,"mode":6}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":33},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":34},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":35},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":36},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":37},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":38},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":39},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":40},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":41},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":42},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":43},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":44},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":45},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":46},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":47},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":48},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":49},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":50},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":51},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":52},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":53},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":54},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":55},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":56},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":57},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":58},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":59},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":60},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":61},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":62},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":63},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":64},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":65},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":66},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":67},"material":10,"mode":1}]},{"primitives":[{"attributes":{"POSITION":68},"material":11,"mode":1}]},{"primitives":[{"attributes":{"POSITION":69},"material":12,"mode":1}]}],"nodes":[{"mesh":0,"translation":[-0,-32,-32]},{"mesh":1,"translation":[-0,-2,-0]},{"mesh":2,"translation":[-0,-4,-0]},{"mesh":3,"translation":[-0,-6,-0]},{"mesh":4,"translation":[-1,-32,-32]},{"mesh":5,"translation":[-1,-2,-0]},{"mesh":6,"translation":[-1,-4,-0]},{"mesh":7,"translation":[-1,-6,-0]},{"mesh":8,"translation":[-1,-8,-0]},{"mesh":9,"translation":[-2,-32,-32]},{"mesh":10,"translation":[-2,-2,-0]},{"mesh":11,"translation":[-2,-4,-0]},{"mesh":12,"translation":[-2,-6,-0]},{"mesh":13,"translation":[-2,-8,-0]},{"mesh":14,"translation":[-2,-10,-0]},{"mesh":15,"translation":[-3,-32,-32]},{"mesh":16,"translation":[-3,-2,-0]},{"mesh":17,"translation":[-3,-4,-0]},{"mesh":17,"translation":[-3,-6,-0]},{"mesh":18,"translation":[-3,-8,-0]},{"mesh":18,"translation":[-3,-10,-0]},{"mesh":19,"translation":[-3,-12,-0]},{"mesh":19,"translation":[-3,-14,-0]},{"mesh":16,"translation":[-3,-16,-0]},{"mesh":15,"translation":[-3,-18,-0]},{"mesh":20,"translation":[-4,-32,-32]},{"mesh":20,"translation":[-4,-2,-0]},{"mesh":21,"translation":[-4,-4,-0]},{"mesh":21,"translation":[-4,-6,-0]},{"mesh":22,"translation":[-4,-8,-0]},{"mesh":22,"translation":[-4,-10,-0]},{"mesh":23,"translation":[-4,-12,-0]},{"mesh":23,"translation":[-4,-14,-0]},{"mesh":24,"translation":[-4,-16,-0]},{"mesh":24,"translation":[-4,-18,-0]},{"mesh":25,"translation":[-4,-20,-0]},{"mesh":25,"translation":[-4,-22,-0]},{"mesh":26,"translation":[-5,-32,-32]},{"mesh":26,"translation":[-5,-2,-0]},{"mesh":26,"translation":[-5,-4,-0]},{"mesh":27,"translation":[-5,-6,-0]},{"mesh":26,"translation":[-5,-8,-0]},{"mesh":28,"translation":[-5,-10,-0]},{"mesh":27,"translation":[-5,-12,-0]},{"mesh":26,"translation":[-5,-14,-0]},{"mesh":27,"translation":[-5,-16,-0]},{"mesh":27,"translation":[-5,-18,-0]},{"mesh":27,"translation":[-5,-20,-0]},{"mesh":28,"translation":[-5,-22,-0]},{"mesh":28,"translation":[-5,-24,-0]},{"mesh":26,"translation":[-5,-26,-0]},{"mesh":28,"translation":[-5,-28,-0]},{"mesh":27,"translation":[-5,-30,-0]},{"mesh":28,"translation":[-5,-32,-0]},{"mesh":28,"translation":[-5,-34,-0]},{"mesh":29,"translation":[-6,-2,-0]},{"mesh":30,"translation":[-6,-4,-0]},{"mesh":31,"translation":[-6,-6,-0]},{"mesh":32,"translation":[-6,-8,-0]},{"mesh":33,"translation":[-6,-14,-0]},{"mesh":34,"translation":[-6,-12,-0]},{"mesh":35,"translation":[-6,-32,-32]},{"mesh":36,"translation":[-7,-2,-0]},{"mesh":36,"translation":[-7,-4,-0]},{"mesh":37,"translation":[-7,-6,-0]},{"mesh":38,"translation":[-7,-8,-0]},{"mesh":38,"translation":[-7,-10,-0]},{"mesh":39,"translation":[-7,-32,-32]},{"mesh":40,"translation":[-8,-2,-0]},{"mesh":41,"translation":[-8,-4,-0]},{"mesh":42,"translation":[-8,-6,-0]},{"mesh":43,"translation":[-8,-12,-0]},{"mesh":44,"translation":[-9,-32,-32]},{"mesh":45,"translation":[-9,-2,-0]},{"mesh":46,"translation":[-9,-4,-0]},{"mesh":46,"translation":[-10,-32,-32]},{"mesh":46,"translation":[-10,-2,-0]},{"mesh":47,"translation":[-11,-32,-32]},{"mesh":48,"translation":[-11,-2,-0]},{"mesh":49,"translation":[-11,-4,-0]},{"mesh":50,"translation":[-11,-6,-0]},{"mesh":51,"translation":[-11,-8,-0]},{"mesh":52,"translation":[-11,-10,-0]},{"mesh":52,"translation":[-11,-12,-0]},{"mesh":53,"translation":[-11,-14,-0]},{"mesh":54,"translation":[-11,-16,-0]},{"mesh":55,"translation":[-11,-18,-0]},{"mesh":56,"translation":[-12,-32,-32]},{"mesh":56,"translation":[-12,-2,-0]},{"mesh":56,"translation":[-12,-4,-0]},{"mesh":56,"translation":[-12,-6,-0]},{"mesh":57,"translation":[-12,-8,-0]},{"mesh":57,"translation":[-12,-10,-0]},{"mesh":58,"translation":[-12,-12,-0]},{"mesh":58,"translation":[-12,-14,-0]},{"mesh":7,"translation":[-14,-32,-32]},{"mesh":28,"translation":[-15,-32,-32]},{"mesh":26,"translation":[-15,-2,-0]},{"mesh":13,"translation":[-16,-2,-0]},{"mesh":49,"translation":[-19,-32,-32]},{"mesh":39,"translation":[-20,-32,-32]},{"mesh":49,"translation":[-21,-32,-32]},{"mesh":59,"translation":[-22,-32,-32]},{"mesh":59,"translation":[-22,-2,-0]},{"mesh":59,"translation":[-23,-32,-32]},{"mesh":47,"translation":[-24,-32,-32]},{"mesh":51,"translation":[-24,-2,-0]},{"mesh":58,"translation":[-24,-4,-0]},{"mesh":58,"translation":[-24,-6,-0]},{"mesh":57,"translation":[-24,-8,-0]},{"mesh":57,"translation":[-24,-10,-0]},{"mesh":44,"translation":[-24,-12,-0]},{"mesh":45,"translation":[-24,-14,-0]},{"mesh":46,"translation":[-24,-16,-0]},{"mesh":60,"translation":[-25,-32,-32]},{"mesh":61,"translation":[-25,-2,-0]},{"mesh":62,"translation":[-25,-4,-0]},{"mesh":63,"translation":[0,0,0]},{"mesh":64,"translation":[0,0,0]},{"mesh":65,"translation":[0,0,0]}],"samplers":[{"magFilter":9728,"minFilter":9728,"wrapS":33071,"wrapT":33071}],"scene":0,"scenes":[{"nodes":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119]}],"textures":[{"name":"gates_texture","sampler":0,"source":0}]} \ No newline at end of file +{"accessors":[{"bufferView":0,"byteOffset":0,"componentType":5126,"count":12,"max":[0,0.5,0.5],"min":[0,-0.5,-0.5],"name":"cube","type":"VEC3"},{"bufferView":1,"byteOffset":0,"componentType":5126,"count":12,"max":[0.0625,0.4375],"min":[0,0.375],"name":"tex_coords_gate_I","type":"VEC2"},{"bufferView":2,"byteOffset":0,"componentType":5126,"count":12,"max":[0.0625,0.4375],"min":[0,0.375],"name":"tex_coords_gate_X","type":"VEC2"},{"bufferView":3,"byteOffset":0,"componentType":5126,"count":12,"max":[0.0625,0.5],"min":[0,0.4375],"name":"tex_coords_gate_Y","type":"VEC2"},{"bufferView":4,"byteOffset":0,"componentType":5126,"count":12,"max":[0.0625,0.5625],"min":[0,0.5],"name":"tex_coords_gate_Z","type":"VEC2"},{"bufferView":5,"byteOffset":0,"componentType":5126,"count":12,"max":[0.125,0.625],"min":[0.0625,0.5625],"name":"tex_coords_gate_C_XYZ","type":"VEC2"},{"bufferView":6,"byteOffset":0,"componentType":5126,"count":12,"max":[0.1875,0.625],"min":[0.125,0.5625],"name":"tex_coords_gate_C_ZYX","type":"VEC2"},{"bufferView":7,"byteOffset":0,"componentType":5126,"count":12,"max":[0.125,0.5625],"min":[0.0625,0.5],"name":"tex_coords_gate_H_XY","type":"VEC2"},{"bufferView":8,"byteOffset":0,"componentType":5126,"count":12,"max":[0.125,0.5],"min":[0.0625,0.4375],"name":"tex_coords_gate_H","type":"VEC2"},{"bufferView":9,"byteOffset":0,"componentType":5126,"count":12,"max":[0.125,0.4375],"min":[0.0625,0.375],"name":"tex_coords_gate_H_YZ","type":"VEC2"},{"bufferView":10,"byteOffset":0,"componentType":5126,"count":12,"max":[0.1875,0.4375],"min":[0.125,0.375],"name":"tex_coords_gate_SQRT_X","type":"VEC2"},{"bufferView":11,"byteOffset":0,"componentType":5126,"count":12,"max":[0.25,0.4375],"min":[0.1875,0.375],"name":"tex_coords_gate_SQRT_X_DAG","type":"VEC2"},{"bufferView":12,"byteOffset":0,"componentType":5126,"count":12,"max":[0.1875,0.5],"min":[0.125,0.4375],"name":"tex_coords_gate_SQRT_Y","type":"VEC2"},{"bufferView":13,"byteOffset":0,"componentType":5126,"count":12,"max":[0.25,0.5],"min":[0.1875,0.4375],"name":"tex_coords_gate_SQRT_Y_DAG","type":"VEC2"},{"bufferView":14,"byteOffset":0,"componentType":5126,"count":12,"max":[0.1875,0.5625],"min":[0.125,0.5],"name":"tex_coords_gate_S","type":"VEC2"},{"bufferView":15,"byteOffset":0,"componentType":5126,"count":12,"max":[0.25,0.5625],"min":[0.1875,0.5],"name":"tex_coords_gate_S_DAG","type":"VEC2"},{"bufferView":16,"byteOffset":0,"componentType":5126,"count":17,"max":[0,0.400000005960464,0.400000005960464],"min":[0,-0.400000005960464,-0.400000005960464],"name":"circle_loop","type":"VEC3"},{"bufferView":17,"byteOffset":0,"componentType":5126,"count":4,"max":[0,0.45254835486412,0.45254835486412],"min":[0,-0.45254835486412,-0.45254835486412],"name":"control_zswap_line_cross","type":"VEC3"},{"bufferView":18,"byteOffset":0,"componentType":5126,"count":17,"max":[0,0.400000005960464,0.400000005960464],"min":[0,-0.400000005960464,-0.400000005960464],"name":"circle_loop","type":"VEC3"},{"bufferView":19,"byteOffset":0,"componentType":5126,"count":4,"max":[0,0.45254835486412,0.45254835486412],"min":[0,-0.45254835486412,-0.45254835486412],"name":"control_xswap_line_cross","type":"VEC3"},{"bufferView":20,"byteOffset":0,"componentType":5126,"count":12,"max":[0.375,0.625],"min":[0.3125,0.5625],"name":"tex_coords_gate_ISWAP","type":"VEC2"},{"bufferView":21,"byteOffset":0,"componentType":5126,"count":12,"max":[0.4375,0.625],"min":[0.375,0.5625],"name":"tex_coords_gate_ISWAP_DAG","type":"VEC2"},{"bufferView":22,"byteOffset":0,"componentType":5126,"count":12,"max":[0.5,0.625],"min":[0.4375,0.5625],"name":"tex_coords_gate_SWAP","type":"VEC2"},{"bufferView":23,"byteOffset":0,"componentType":5126,"count":12,"max":[0.75,0.4375],"min":[0.6875,0.375],"name":"tex_coords_gate_SQRT_XX","type":"VEC2"},{"bufferView":24,"byteOffset":0,"componentType":5126,"count":12,"max":[0.8125,0.4375],"min":[0.75,0.375],"name":"tex_coords_gate_SQRT_XX_DAG","type":"VEC2"},{"bufferView":25,"byteOffset":0,"componentType":5126,"count":12,"max":[0.75,0.5],"min":[0.6875,0.4375],"name":"tex_coords_gate_SQRT_YY","type":"VEC2"},{"bufferView":26,"byteOffset":0,"componentType":5126,"count":12,"max":[0.8125,0.5],"min":[0.75,0.4375],"name":"tex_coords_gate_SQRT_YY_DAG","type":"VEC2"},{"bufferView":27,"byteOffset":0,"componentType":5126,"count":12,"max":[0.75,0.5625],"min":[0.6875,0.5],"name":"tex_coords_gate_SQRT_ZZ","type":"VEC2"},{"bufferView":28,"byteOffset":0,"componentType":5126,"count":12,"max":[0.8125,0.5625],"min":[0.75,0.5],"name":"tex_coords_gate_SQRT_ZZ_DAG","type":"VEC2"},{"bufferView":29,"byteOffset":0,"componentType":5126,"count":17,"max":[0,0.400000005960464,0.400000005960464],"min":[0,-0.400000005960464,-0.400000005960464],"name":"circle_loop","type":"VEC3"},{"bufferView":30,"byteOffset":0,"componentType":5126,"count":4,"max":[0,0.400000005960464,0.400000005960464],"min":[0,-0.400000005960464,-0.400000005960464],"name":"control_x_line_cross","type":"VEC3"},{"bufferView":31,"byteOffset":0,"componentType":5126,"count":3,"max":[0,0.400000005960464,0.346410155296326],"min":[0,-0.200000032782555,-0.346410185098648],"name":"circle_loop","type":"VEC3"},{"bufferView":32,"byteOffset":0,"componentType":5126,"count":17,"max":[0,0.400000005960464,0.400000005960464],"min":[0,-0.400000005960464,-0.400000005960464],"name":"circle_loop","type":"VEC3"},{"bufferView":33,"byteOffset":0,"componentType":5126,"count":12,"max":[0.5625,0.4375],"min":[0.5,0.375],"name":"tex_coords_gate_E:X","type":"VEC2"},{"bufferView":34,"byteOffset":0,"componentType":5126,"count":12,"max":[0.5625,0.5],"min":[0.5,0.4375],"name":"tex_coords_gate_E:Y","type":"VEC2"},{"bufferView":35,"byteOffset":0,"componentType":5126,"count":12,"max":[0.5625,0.5625],"min":[0.5,0.5],"name":"tex_coords_gate_E:Z","type":"VEC2"},{"bufferView":36,"byteOffset":0,"componentType":5126,"count":12,"max":[0.625,0.4375],"min":[0.5625,0.375],"name":"tex_coords_gate_ELSE_CORRELATED_ERROR:X","type":"VEC2"},{"bufferView":37,"byteOffset":0,"componentType":5126,"count":12,"max":[0.625,0.5],"min":[0.5625,0.4375],"name":"tex_coords_gate_ELSE_CORRELATED_ERROR:Y","type":"VEC2"},{"bufferView":38,"byteOffset":0,"componentType":5126,"count":12,"max":[0.625,0.5625],"min":[0.5625,0.5],"name":"tex_coords_gate_ELSE_CORRELATED_ERROR:Z","type":"VEC2"},{"bufferView":39,"byteOffset":0,"componentType":5126,"count":12,"max":[0.25,0.625],"min":[0.1875,0.5625],"name":"tex_coords_gate_DEPOLARIZE1","type":"VEC2"},{"bufferView":40,"byteOffset":0,"componentType":5126,"count":12,"max":[0.3125,0.625],"min":[0.25,0.5625],"name":"tex_coords_gate_DEPOLARIZE2","type":"VEC2"},{"bufferView":41,"byteOffset":0,"componentType":5126,"count":12,"max":[0.5625,0.625],"min":[0.5,0.5625],"name":"tex_coords_gate_PAULI_CHANNEL_1","type":"VEC2"},{"bufferView":42,"byteOffset":0,"componentType":5126,"count":12,"max":[0.625,0.625],"min":[0.5625,0.5625],"name":"tex_coords_gate_PAULI_CHANNEL_2","type":"VEC2"},{"bufferView":43,"byteOffset":0,"componentType":5126,"count":12,"max":[0.5,0.4375],"min":[0.4375,0.375],"name":"tex_coords_gate_X_ERROR","type":"VEC2"},{"bufferView":44,"byteOffset":0,"componentType":5126,"count":12,"max":[0.5,0.5],"min":[0.4375,0.4375],"name":"tex_coords_gate_Y_ERROR","type":"VEC2"},{"bufferView":45,"byteOffset":0,"componentType":5126,"count":12,"max":[0.5,0.5625],"min":[0.4375,0.5],"name":"tex_coords_gate_Z_ERROR","type":"VEC2"},{"bufferView":46,"byteOffset":0,"componentType":5126,"count":12,"max":[0.9375,0.625],"min":[0.875,0.5625],"name":"tex_coords_gate_HERALDED_ERASE","type":"VEC2"},{"bufferView":47,"byteOffset":0,"componentType":5126,"count":12,"max":[1,0.625],"min":[0.9375,0.5625],"name":"tex_coords_gate_HERALDED_PAULI_CHANNEL_1","type":"VEC2"},{"bufferView":48,"byteOffset":0,"componentType":5126,"count":12,"max":[0.6875,0.4375],"min":[0.625,0.375],"name":"tex_coords_gate_MPP:X","type":"VEC2"},{"bufferView":49,"byteOffset":0,"componentType":5126,"count":12,"max":[0.6875,0.5],"min":[0.625,0.4375],"name":"tex_coords_gate_MPP:Y","type":"VEC2"},{"bufferView":50,"byteOffset":0,"componentType":5126,"count":12,"max":[0.6875,0.5625],"min":[0.625,0.5],"name":"tex_coords_gate_MPP:Z","type":"VEC2"},{"bufferView":51,"byteOffset":0,"componentType":5126,"count":12,"max":[0.4375,0.4375],"min":[0.375,0.375],"name":"tex_coords_gate_MRX","type":"VEC2"},{"bufferView":52,"byteOffset":0,"componentType":5126,"count":12,"max":[0.4375,0.5],"min":[0.375,0.4375],"name":"tex_coords_gate_MRY","type":"VEC2"},{"bufferView":53,"byteOffset":0,"componentType":5126,"count":12,"max":[0.4375,0.5625],"min":[0.375,0.5],"name":"tex_coords_gate_MR","type":"VEC2"},{"bufferView":54,"byteOffset":0,"componentType":5126,"count":12,"max":[0.3125,0.4375],"min":[0.25,0.375],"name":"tex_coords_gate_MX","type":"VEC2"},{"bufferView":55,"byteOffset":0,"componentType":5126,"count":12,"max":[0.3125,0.5],"min":[0.25,0.4375],"name":"tex_coords_gate_MY","type":"VEC2"},{"bufferView":56,"byteOffset":0,"componentType":5126,"count":12,"max":[0.3125,0.5625],"min":[0.25,0.5],"name":"tex_coords_gate_M","type":"VEC2"},{"bufferView":57,"byteOffset":0,"componentType":5126,"count":12,"max":[0.375,0.4375],"min":[0.3125,0.375],"name":"tex_coords_gate_RX","type":"VEC2"},{"bufferView":58,"byteOffset":0,"componentType":5126,"count":12,"max":[0.375,0.5],"min":[0.3125,0.4375],"name":"tex_coords_gate_RY","type":"VEC2"},{"bufferView":59,"byteOffset":0,"componentType":5126,"count":12,"max":[0.375,0.5625],"min":[0.3125,0.5],"name":"tex_coords_gate_R","type":"VEC2"},{"bufferView":60,"byteOffset":0,"componentType":5126,"count":12,"max":[0.6875,0.625],"min":[0.625,0.5625],"name":"tex_coords_gate_MXX","type":"VEC2"},{"bufferView":61,"byteOffset":0,"componentType":5126,"count":12,"max":[0.75,0.625],"min":[0.6875,0.5625],"name":"tex_coords_gate_MYY","type":"VEC2"},{"bufferView":62,"byteOffset":0,"componentType":5126,"count":12,"max":[0.8125,0.625],"min":[0.75,0.5625],"name":"tex_coords_gate_MZZ","type":"VEC2"},{"bufferView":63,"byteOffset":0,"componentType":5126,"count":12,"max":[0.875,0.625],"min":[0.8125,0.5625],"name":"tex_coords_gate_MPAD","type":"VEC2"},{"bufferView":64,"byteOffset":0,"componentType":5126,"count":12,"max":[0.875,0.4375],"min":[0.8125,0.375],"name":"tex_coords_gate_X:REC","type":"VEC2"},{"bufferView":65,"byteOffset":0,"componentType":5126,"count":12,"max":[0.9375,0.5],"min":[0.875,0.4375],"name":"tex_coords_gate_Y:SWEEP","type":"VEC2"},{"bufferView":66,"byteOffset":0,"componentType":5126,"count":12,"max":[0.875,0.5625],"min":[0.8125,0.5],"name":"tex_coords_gate_Z:REC","type":"VEC2"},{"bufferView":67,"byteOffset":0,"componentType":5126,"count":130,"max":[1,-2,-0],"min":[-26,-34,-32],"name":"buf_scattered_lines","type":"VEC3"},{"bufferView":68,"byteOffset":0,"componentType":5126,"count":30,"max":[0,0.5,1],"min":[-17.25,-35,-33],"name":"buf_red_scattered_lines","type":"VEC3"},{"bufferView":69,"byteOffset":0,"componentType":5126,"count":96,"max":[-0.75,-1.20000004768372,0.5],"min":[-23.25,-1.60000002384186,-32.5],"name":"buf_blue_scattered_lines","type":"VEC3"}],"asset":{"version":"2.0"},"bufferViews":[{"buffer":0,"byteLength":144,"byteOffset":0,"name":"cube","target":34962},{"buffer":1,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_I","target":34962},{"buffer":2,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_X","target":34962},{"buffer":3,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_Y","target":34962},{"buffer":4,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_Z","target":34962},{"buffer":5,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_C_XYZ","target":34962},{"buffer":6,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_C_ZYX","target":34962},{"buffer":7,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_H_XY","target":34962},{"buffer":8,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_H","target":34962},{"buffer":9,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_H_YZ","target":34962},{"buffer":10,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_SQRT_X","target":34962},{"buffer":11,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_SQRT_X_DAG","target":34962},{"buffer":12,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_SQRT_Y","target":34962},{"buffer":13,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_SQRT_Y_DAG","target":34962},{"buffer":14,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_S","target":34962},{"buffer":15,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_S_DAG","target":34962},{"buffer":16,"byteLength":204,"byteOffset":0,"name":"circle_loop","target":34962},{"buffer":17,"byteLength":48,"byteOffset":0,"name":"control_zswap_line_cross","target":34962},{"buffer":18,"byteLength":204,"byteOffset":0,"name":"circle_loop","target":34962},{"buffer":19,"byteLength":48,"byteOffset":0,"name":"control_xswap_line_cross","target":34962},{"buffer":20,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_ISWAP","target":34962},{"buffer":21,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_ISWAP_DAG","target":34962},{"buffer":22,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_SWAP","target":34962},{"buffer":23,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_SQRT_XX","target":34962},{"buffer":24,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_SQRT_XX_DAG","target":34962},{"buffer":25,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_SQRT_YY","target":34962},{"buffer":26,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_SQRT_YY_DAG","target":34962},{"buffer":27,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_SQRT_ZZ","target":34962},{"buffer":28,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_SQRT_ZZ_DAG","target":34962},{"buffer":29,"byteLength":204,"byteOffset":0,"name":"circle_loop","target":34962},{"buffer":30,"byteLength":48,"byteOffset":0,"name":"control_x_line_cross","target":34962},{"buffer":31,"byteLength":36,"byteOffset":0,"name":"circle_loop","target":34962},{"buffer":32,"byteLength":204,"byteOffset":0,"name":"circle_loop","target":34962},{"buffer":33,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_E:X","target":34962},{"buffer":34,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_E:Y","target":34962},{"buffer":35,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_E:Z","target":34962},{"buffer":36,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_ELSE_CORRELATED_ERROR:X","target":34962},{"buffer":37,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_ELSE_CORRELATED_ERROR:Y","target":34962},{"buffer":38,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_ELSE_CORRELATED_ERROR:Z","target":34962},{"buffer":39,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_DEPOLARIZE1","target":34962},{"buffer":40,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_DEPOLARIZE2","target":34962},{"buffer":41,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_PAULI_CHANNEL_1","target":34962},{"buffer":42,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_PAULI_CHANNEL_2","target":34962},{"buffer":43,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_X_ERROR","target":34962},{"buffer":44,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_Y_ERROR","target":34962},{"buffer":45,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_Z_ERROR","target":34962},{"buffer":46,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_HERALDED_ERASE","target":34962},{"buffer":47,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_HERALDED_PAULI_CHANNEL_1","target":34962},{"buffer":48,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_MPP:X","target":34962},{"buffer":49,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_MPP:Y","target":34962},{"buffer":50,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_MPP:Z","target":34962},{"buffer":51,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_MRX","target":34962},{"buffer":52,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_MRY","target":34962},{"buffer":53,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_MR","target":34962},{"buffer":54,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_MX","target":34962},{"buffer":55,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_MY","target":34962},{"buffer":56,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_M","target":34962},{"buffer":57,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_RX","target":34962},{"buffer":58,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_RY","target":34962},{"buffer":59,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_R","target":34962},{"buffer":60,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_MXX","target":34962},{"buffer":61,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_MYY","target":34962},{"buffer":62,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_MZZ","target":34962},{"buffer":63,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_MPAD","target":34962},{"buffer":64,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_X:REC","target":34962},{"buffer":65,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_Y:SWEEP","target":34962},{"buffer":66,"byteLength":96,"byteOffset":0,"name":"tex_coords_gate_Z:REC","target":34962},{"buffer":67,"byteLength":1560,"byteOffset":0,"name":"buf_scattered_lines","target":34962},{"buffer":68,"byteLength":360,"byteOffset":0,"name":"buf_red_scattered_lines","target":34962},{"buffer":69,"byteLength":1152,"byteOffset":0,"name":"buf_blue_scattered_lines","target":34962}],"buffers":[{"byteLength":144,"name":"cube","uri":"data:application/octet-stream;base64,AAAAAAAAAD8AAAA/AAAAAAAAAD8AAAC/AAAAAAAAAL8AAAA/AAAAAAAAAD8AAAC/AAAAAAAAAL8AAAC/AAAAAAAAAL8AAAA/AAAAAAAAAL8AAAC/AAAAAAAAAD8AAAC/AAAAAAAAAL8AAAA/AAAAAAAAAL8AAAA/AAAAAAAAAD8AAAC/AAAAAAAAAD8AAAA/"},{"byteLength":96,"name":"tex_coords_gate_I","uri":"data:application/octet-stream;base64,AACAPQAAwD4AAAAAAADAPgAAgD0AAOA+AAAAAAAAwD4AAAAAAADgPgAAgD0AAOA+AACAPQAA4D4AAIA9AADAPgAAAAAAAOA+AAAAAAAA4D4AAIA9AADAPgAAAAAAAMA+"},{"byteLength":96,"name":"tex_coords_gate_X","uri":"data:application/octet-stream;base64,AACAPQAAwD4AAAAAAADAPgAAgD0AAOA+AAAAAAAAwD4AAAAAAADgPgAAgD0AAOA+AACAPQAA4D4AAIA9AADAPgAAAAAAAOA+AAAAAAAA4D4AAIA9AADAPgAAAAAAAMA+"},{"byteLength":96,"name":"tex_coords_gate_Y","uri":"data:application/octet-stream;base64,AACAPQAA4D4AAAAAAADgPgAAgD0AAAA/AAAAAAAA4D4AAAAAAAAAPwAAgD0AAAA/AACAPQAAAD8AAIA9AADgPgAAAAAAAAA/AAAAAAAAAD8AAIA9AADgPgAAAAAAAOA+"},{"byteLength":96,"name":"tex_coords_gate_Z","uri":"data:application/octet-stream;base64,AACAPQAAAD8AAAAAAAAAPwAAgD0AABA/AAAAAAAAAD8AAAAAAAAQPwAAgD0AABA/AACAPQAAED8AAIA9AAAAPwAAAAAAABA/AAAAAAAAED8AAIA9AAAAPwAAAAAAAAA/"},{"byteLength":96,"name":"tex_coords_gate_C_XYZ","uri":"data:application/octet-stream;base64,AAAAPgAAED8AAIA9AAAQPwAAAD4AACA/AACAPQAAED8AAIA9AAAgPwAAAD4AACA/AAAAPgAAID8AAAA+AAAQPwAAgD0AACA/AACAPQAAID8AAAA+AAAQPwAAgD0AABA/"},{"byteLength":96,"name":"tex_coords_gate_C_ZYX","uri":"data:application/octet-stream;base64,AABAPgAAED8AAAA+AAAQPwAAQD4AACA/AAAAPgAAED8AAAA+AAAgPwAAQD4AACA/AABAPgAAID8AAEA+AAAQPwAAAD4AACA/AAAAPgAAID8AAEA+AAAQPwAAAD4AABA/"},{"byteLength":96,"name":"tex_coords_gate_H_XY","uri":"data:application/octet-stream;base64,AAAAPgAAAD8AAIA9AAAAPwAAAD4AABA/AACAPQAAAD8AAIA9AAAQPwAAAD4AABA/AAAAPgAAED8AAAA+AAAAPwAAgD0AABA/AACAPQAAED8AAAA+AAAAPwAAgD0AAAA/"},{"byteLength":96,"name":"tex_coords_gate_H","uri":"data:application/octet-stream;base64,AAAAPgAA4D4AAIA9AADgPgAAAD4AAAA/AACAPQAA4D4AAIA9AAAAPwAAAD4AAAA/AAAAPgAAAD8AAAA+AADgPgAAgD0AAAA/AACAPQAAAD8AAAA+AADgPgAAgD0AAOA+"},{"byteLength":96,"name":"tex_coords_gate_H_YZ","uri":"data:application/octet-stream;base64,AAAAPgAAwD4AAIA9AADAPgAAAD4AAOA+AACAPQAAwD4AAIA9AADgPgAAAD4AAOA+AAAAPgAA4D4AAAA+AADAPgAAgD0AAOA+AACAPQAA4D4AAAA+AADAPgAAgD0AAMA+"},{"byteLength":96,"name":"tex_coords_gate_SQRT_X","uri":"data:application/octet-stream;base64,AABAPgAAwD4AAAA+AADAPgAAQD4AAOA+AAAAPgAAwD4AAAA+AADgPgAAQD4AAOA+AABAPgAA4D4AAEA+AADAPgAAAD4AAOA+AAAAPgAA4D4AAEA+AADAPgAAAD4AAMA+"},{"byteLength":96,"name":"tex_coords_gate_SQRT_X_DAG","uri":"data:application/octet-stream;base64,AACAPgAAwD4AAEA+AADAPgAAgD4AAOA+AABAPgAAwD4AAEA+AADgPgAAgD4AAOA+AACAPgAA4D4AAIA+AADAPgAAQD4AAOA+AABAPgAA4D4AAIA+AADAPgAAQD4AAMA+"},{"byteLength":96,"name":"tex_coords_gate_SQRT_Y","uri":"data:application/octet-stream;base64,AABAPgAA4D4AAAA+AADgPgAAQD4AAAA/AAAAPgAA4D4AAAA+AAAAPwAAQD4AAAA/AABAPgAAAD8AAEA+AADgPgAAAD4AAAA/AAAAPgAAAD8AAEA+AADgPgAAAD4AAOA+"},{"byteLength":96,"name":"tex_coords_gate_SQRT_Y_DAG","uri":"data:application/octet-stream;base64,AACAPgAA4D4AAEA+AADgPgAAgD4AAAA/AABAPgAA4D4AAEA+AAAAPwAAgD4AAAA/AACAPgAAAD8AAIA+AADgPgAAQD4AAAA/AABAPgAAAD8AAIA+AADgPgAAQD4AAOA+"},{"byteLength":96,"name":"tex_coords_gate_S","uri":"data:application/octet-stream;base64,AABAPgAAAD8AAAA+AAAAPwAAQD4AABA/AAAAPgAAAD8AAAA+AAAQPwAAQD4AABA/AABAPgAAED8AAEA+AAAAPwAAAD4AABA/AAAAPgAAED8AAEA+AAAAPwAAAD4AAAA/"},{"byteLength":96,"name":"tex_coords_gate_S_DAG","uri":"data:application/octet-stream;base64,AACAPgAAAD8AAEA+AAAAPwAAgD4AABA/AABAPgAAAD8AAEA+AAAQPwAAgD4AABA/AACAPgAAED8AAIA+AAAAPwAAQD4AABA/AABAPgAAED8AAIA+AAAAPwAAQD4AAAA/"},{"byteLength":204,"name":"circle_loop","uri":"data:application/octet-stream;base64,AAAAAM3MzD4AAAAAAAAAAOU1vT5Fvxw+AAAAAMPQkD7D0JA+AAAAAES/HD7lNb0+AAAAAPIwlrLNzMw+AAAAAEe/HL7lNb0+AAAAAMPQkL7D0JA+AAAAAOc1vb5Avxw+AAAAAM3MzL7yMBazAAAAAOU1vb5Evxy+AAAAAMHQkL7E0JC+AAAAADy/HL7nNb2+AAAAAPLkozHNzMy+AAAAAEm/HD7kNb2+AAAAAMbQkD6/0JC+AAAAAOY1vT5Evxy+AAAAAM3MzD4AAAAA"},{"byteLength":48,"name":"control_zswap_line_cross","uri":"data:application/octet-stream;base64,AAAAAGu0575rtOe+AAAAAGu05z5rtOc+AAAAAGu0575rtOc+AAAAAGu05z5rtOe+"},{"byteLength":204,"name":"circle_loop","uri":"data:application/octet-stream;base64,AAAAAM3MzD4AAAAAAAAAAOU1vT5Fvxw+AAAAAMPQkD7D0JA+AAAAAES/HD7lNb0+AAAAAPIwlrLNzMw+AAAAAEe/HL7lNb0+AAAAAMPQkL7D0JA+AAAAAOc1vb5Avxw+AAAAAM3MzL7yMBazAAAAAOU1vb5Evxy+AAAAAMHQkL7E0JC+AAAAADy/HL7nNb2+AAAAAPLkozHNzMy+AAAAAEm/HD7kNb2+AAAAAMbQkD6/0JC+AAAAAOY1vT5Evxy+AAAAAM3MzD4AAAAA"},{"byteLength":48,"name":"control_xswap_line_cross","uri":"data:application/octet-stream;base64,AAAAAGu0575rtOe+AAAAAGu05z5rtOc+AAAAAGu0575rtOc+AAAAAGu05z5rtOe+"},{"byteLength":96,"name":"tex_coords_gate_ISWAP","uri":"data:application/octet-stream;base64,AADAPgAAED8AAKA+AAAQPwAAwD4AACA/AACgPgAAED8AAKA+AAAgPwAAwD4AACA/AADAPgAAID8AAMA+AAAQPwAAoD4AACA/AACgPgAAID8AAMA+AAAQPwAAoD4AABA/"},{"byteLength":96,"name":"tex_coords_gate_ISWAP_DAG","uri":"data:application/octet-stream;base64,AADgPgAAED8AAMA+AAAQPwAA4D4AACA/AADAPgAAED8AAMA+AAAgPwAA4D4AACA/AADgPgAAID8AAOA+AAAQPwAAwD4AACA/AADAPgAAID8AAOA+AAAQPwAAwD4AABA/"},{"byteLength":96,"name":"tex_coords_gate_SWAP","uri":"data:application/octet-stream;base64,AAAAPwAAED8AAOA+AAAQPwAAAD8AACA/AADgPgAAED8AAOA+AAAgPwAAAD8AACA/AAAAPwAAID8AAAA/AAAQPwAA4D4AACA/AADgPgAAID8AAAA/AAAQPwAA4D4AABA/"},{"byteLength":96,"name":"tex_coords_gate_SQRT_XX","uri":"data:application/octet-stream;base64,AABAPwAAwD4AADA/AADAPgAAQD8AAOA+AAAwPwAAwD4AADA/AADgPgAAQD8AAOA+AABAPwAA4D4AAEA/AADAPgAAMD8AAOA+AAAwPwAA4D4AAEA/AADAPgAAMD8AAMA+"},{"byteLength":96,"name":"tex_coords_gate_SQRT_XX_DAG","uri":"data:application/octet-stream;base64,AABQPwAAwD4AAEA/AADAPgAAUD8AAOA+AABAPwAAwD4AAEA/AADgPgAAUD8AAOA+AABQPwAA4D4AAFA/AADAPgAAQD8AAOA+AABAPwAA4D4AAFA/AADAPgAAQD8AAMA+"},{"byteLength":96,"name":"tex_coords_gate_SQRT_YY","uri":"data:application/octet-stream;base64,AABAPwAA4D4AADA/AADgPgAAQD8AAAA/AAAwPwAA4D4AADA/AAAAPwAAQD8AAAA/AABAPwAAAD8AAEA/AADgPgAAMD8AAAA/AAAwPwAAAD8AAEA/AADgPgAAMD8AAOA+"},{"byteLength":96,"name":"tex_coords_gate_SQRT_YY_DAG","uri":"data:application/octet-stream;base64,AABQPwAA4D4AAEA/AADgPgAAUD8AAAA/AABAPwAA4D4AAEA/AAAAPwAAUD8AAAA/AABQPwAAAD8AAFA/AADgPgAAQD8AAAA/AABAPwAAAD8AAFA/AADgPgAAQD8AAOA+"},{"byteLength":96,"name":"tex_coords_gate_SQRT_ZZ","uri":"data:application/octet-stream;base64,AABAPwAAAD8AADA/AAAAPwAAQD8AABA/AAAwPwAAAD8AADA/AAAQPwAAQD8AABA/AABAPwAAED8AAEA/AAAAPwAAMD8AABA/AAAwPwAAED8AAEA/AAAAPwAAMD8AAAA/"},{"byteLength":96,"name":"tex_coords_gate_SQRT_ZZ_DAG","uri":"data:application/octet-stream;base64,AABQPwAAAD8AAEA/AAAAPwAAUD8AABA/AABAPwAAAD8AAEA/AAAQPwAAUD8AABA/AABQPwAAED8AAFA/AAAAPwAAQD8AABA/AABAPwAAED8AAFA/AAAAPwAAQD8AAAA/"},{"byteLength":204,"name":"circle_loop","uri":"data:application/octet-stream;base64,AAAAAM3MzD4AAAAAAAAAAOU1vT5Fvxw+AAAAAMPQkD7D0JA+AAAAAES/HD7lNb0+AAAAAPIwlrLNzMw+AAAAAEe/HL7lNb0+AAAAAMPQkL7D0JA+AAAAAOc1vb5Avxw+AAAAAM3MzL7yMBazAAAAAOU1vb5Evxy+AAAAAMHQkL7E0JC+AAAAADy/HL7nNb2+AAAAAPLkozHNzMy+AAAAAEm/HD7kNb2+AAAAAMbQkD6/0JC+AAAAAOY1vT5Evxy+AAAAAM3MzD4AAAAA"},{"byteLength":48,"name":"control_x_line_cross","uri":"data:application/octet-stream;base64,AAAAAM3MzL4AAAAAAAAAAM3MzD4AAAAAAAAAAAAAAADNzMy+AAAAAAAAAADNzMw+"},{"byteLength":36,"name":"circle_loop","uri":"data:application/octet-stream;base64,AAAAAM3MzD4AAAAAAAAAAM/MTL6sXLE+AAAAAMvMTL6tXLG+"},{"byteLength":204,"name":"circle_loop","uri":"data:application/octet-stream;base64,AAAAAM3MzD4AAAAAAAAAAOU1vT5Fvxw+AAAAAMPQkD7D0JA+AAAAAES/HD7lNb0+AAAAAPIwlrLNzMw+AAAAAEe/HL7lNb0+AAAAAMPQkL7D0JA+AAAAAOc1vb5Avxw+AAAAAM3MzL7yMBazAAAAAOU1vb5Evxy+AAAAAMHQkL7E0JC+AAAAADy/HL7nNb2+AAAAAPLkozHNzMy+AAAAAEm/HD7kNb2+AAAAAMbQkD6/0JC+AAAAAOY1vT5Evxy+AAAAAM3MzD4AAAAA"},{"byteLength":96,"name":"tex_coords_gate_E:X","uri":"data:application/octet-stream;base64,AAAQPwAAwD4AAAA/AADAPgAAED8AAOA+AAAAPwAAwD4AAAA/AADgPgAAED8AAOA+AAAQPwAA4D4AABA/AADAPgAAAD8AAOA+AAAAPwAA4D4AABA/AADAPgAAAD8AAMA+"},{"byteLength":96,"name":"tex_coords_gate_E:Y","uri":"data:application/octet-stream;base64,AAAQPwAA4D4AAAA/AADgPgAAED8AAAA/AAAAPwAA4D4AAAA/AAAAPwAAED8AAAA/AAAQPwAAAD8AABA/AADgPgAAAD8AAAA/AAAAPwAAAD8AABA/AADgPgAAAD8AAOA+"},{"byteLength":96,"name":"tex_coords_gate_E:Z","uri":"data:application/octet-stream;base64,AAAQPwAAAD8AAAA/AAAAPwAAED8AABA/AAAAPwAAAD8AAAA/AAAQPwAAED8AABA/AAAQPwAAED8AABA/AAAAPwAAAD8AABA/AAAAPwAAED8AABA/AAAAPwAAAD8AAAA/"},{"byteLength":96,"name":"tex_coords_gate_ELSE_CORRELATED_ERROR:X","uri":"data:application/octet-stream;base64,AAAgPwAAwD4AABA/AADAPgAAID8AAOA+AAAQPwAAwD4AABA/AADgPgAAID8AAOA+AAAgPwAA4D4AACA/AADAPgAAED8AAOA+AAAQPwAA4D4AACA/AADAPgAAED8AAMA+"},{"byteLength":96,"name":"tex_coords_gate_ELSE_CORRELATED_ERROR:Y","uri":"data:application/octet-stream;base64,AAAgPwAA4D4AABA/AADgPgAAID8AAAA/AAAQPwAA4D4AABA/AAAAPwAAID8AAAA/AAAgPwAAAD8AACA/AADgPgAAED8AAAA/AAAQPwAAAD8AACA/AADgPgAAED8AAOA+"},{"byteLength":96,"name":"tex_coords_gate_ELSE_CORRELATED_ERROR:Z","uri":"data:application/octet-stream;base64,AAAgPwAAAD8AABA/AAAAPwAAID8AABA/AAAQPwAAAD8AABA/AAAQPwAAID8AABA/AAAgPwAAED8AACA/AAAAPwAAED8AABA/AAAQPwAAED8AACA/AAAAPwAAED8AAAA/"},{"byteLength":96,"name":"tex_coords_gate_DEPOLARIZE1","uri":"data:application/octet-stream;base64,AACAPgAAED8AAEA+AAAQPwAAgD4AACA/AABAPgAAED8AAEA+AAAgPwAAgD4AACA/AACAPgAAID8AAIA+AAAQPwAAQD4AACA/AABAPgAAID8AAIA+AAAQPwAAQD4AABA/"},{"byteLength":96,"name":"tex_coords_gate_DEPOLARIZE2","uri":"data:application/octet-stream;base64,AACgPgAAED8AAIA+AAAQPwAAoD4AACA/AACAPgAAED8AAIA+AAAgPwAAoD4AACA/AACgPgAAID8AAKA+AAAQPwAAgD4AACA/AACAPgAAID8AAKA+AAAQPwAAgD4AABA/"},{"byteLength":96,"name":"tex_coords_gate_PAULI_CHANNEL_1","uri":"data:application/octet-stream;base64,AAAQPwAAED8AAAA/AAAQPwAAED8AACA/AAAAPwAAED8AAAA/AAAgPwAAED8AACA/AAAQPwAAID8AABA/AAAQPwAAAD8AACA/AAAAPwAAID8AABA/AAAQPwAAAD8AABA/"},{"byteLength":96,"name":"tex_coords_gate_PAULI_CHANNEL_2","uri":"data:application/octet-stream;base64,AAAgPwAAED8AABA/AAAQPwAAID8AACA/AAAQPwAAED8AABA/AAAgPwAAID8AACA/AAAgPwAAID8AACA/AAAQPwAAED8AACA/AAAQPwAAID8AACA/AAAQPwAAED8AABA/"},{"byteLength":96,"name":"tex_coords_gate_X_ERROR","uri":"data:application/octet-stream;base64,AAAAPwAAwD4AAOA+AADAPgAAAD8AAOA+AADgPgAAwD4AAOA+AADgPgAAAD8AAOA+AAAAPwAA4D4AAAA/AADAPgAA4D4AAOA+AADgPgAA4D4AAAA/AADAPgAA4D4AAMA+"},{"byteLength":96,"name":"tex_coords_gate_Y_ERROR","uri":"data:application/octet-stream;base64,AAAAPwAA4D4AAOA+AADgPgAAAD8AAAA/AADgPgAA4D4AAOA+AAAAPwAAAD8AAAA/AAAAPwAAAD8AAAA/AADgPgAA4D4AAAA/AADgPgAAAD8AAAA/AADgPgAA4D4AAOA+"},{"byteLength":96,"name":"tex_coords_gate_Z_ERROR","uri":"data:application/octet-stream;base64,AAAAPwAAAD8AAOA+AAAAPwAAAD8AABA/AADgPgAAAD8AAOA+AAAQPwAAAD8AABA/AAAAPwAAED8AAAA/AAAAPwAA4D4AABA/AADgPgAAED8AAAA/AAAAPwAA4D4AAAA/"},{"byteLength":96,"name":"tex_coords_gate_HERALDED_ERASE","uri":"data:application/octet-stream;base64,AABwPwAAED8AAGA/AAAQPwAAcD8AACA/AABgPwAAED8AAGA/AAAgPwAAcD8AACA/AABwPwAAID8AAHA/AAAQPwAAYD8AACA/AABgPwAAID8AAHA/AAAQPwAAYD8AABA/"},{"byteLength":96,"name":"tex_coords_gate_HERALDED_PAULI_CHANNEL_1","uri":"data:application/octet-stream;base64,AACAPwAAED8AAHA/AAAQPwAAgD8AACA/AABwPwAAED8AAHA/AAAgPwAAgD8AACA/AACAPwAAID8AAIA/AAAQPwAAcD8AACA/AABwPwAAID8AAIA/AAAQPwAAcD8AABA/"},{"byteLength":96,"name":"tex_coords_gate_MPP:X","uri":"data:application/octet-stream;base64,AAAwPwAAwD4AACA/AADAPgAAMD8AAOA+AAAgPwAAwD4AACA/AADgPgAAMD8AAOA+AAAwPwAA4D4AADA/AADAPgAAID8AAOA+AAAgPwAA4D4AADA/AADAPgAAID8AAMA+"},{"byteLength":96,"name":"tex_coords_gate_MPP:Y","uri":"data:application/octet-stream;base64,AAAwPwAA4D4AACA/AADgPgAAMD8AAAA/AAAgPwAA4D4AACA/AAAAPwAAMD8AAAA/AAAwPwAAAD8AADA/AADgPgAAID8AAAA/AAAgPwAAAD8AADA/AADgPgAAID8AAOA+"},{"byteLength":96,"name":"tex_coords_gate_MPP:Z","uri":"data:application/octet-stream;base64,AAAwPwAAAD8AACA/AAAAPwAAMD8AABA/AAAgPwAAAD8AACA/AAAQPwAAMD8AABA/AAAwPwAAED8AADA/AAAAPwAAID8AABA/AAAgPwAAED8AADA/AAAAPwAAID8AAAA/"},{"byteLength":96,"name":"tex_coords_gate_MRX","uri":"data:application/octet-stream;base64,AADgPgAAwD4AAMA+AADAPgAA4D4AAOA+AADAPgAAwD4AAMA+AADgPgAA4D4AAOA+AADgPgAA4D4AAOA+AADAPgAAwD4AAOA+AADAPgAA4D4AAOA+AADAPgAAwD4AAMA+"},{"byteLength":96,"name":"tex_coords_gate_MRY","uri":"data:application/octet-stream;base64,AADgPgAA4D4AAMA+AADgPgAA4D4AAAA/AADAPgAA4D4AAMA+AAAAPwAA4D4AAAA/AADgPgAAAD8AAOA+AADgPgAAwD4AAAA/AADAPgAAAD8AAOA+AADgPgAAwD4AAOA+"},{"byteLength":96,"name":"tex_coords_gate_MR","uri":"data:application/octet-stream;base64,AADgPgAAAD8AAMA+AAAAPwAA4D4AABA/AADAPgAAAD8AAMA+AAAQPwAA4D4AABA/AADgPgAAED8AAOA+AAAAPwAAwD4AABA/AADAPgAAED8AAOA+AAAAPwAAwD4AAAA/"},{"byteLength":96,"name":"tex_coords_gate_MX","uri":"data:application/octet-stream;base64,AACgPgAAwD4AAIA+AADAPgAAoD4AAOA+AACAPgAAwD4AAIA+AADgPgAAoD4AAOA+AACgPgAA4D4AAKA+AADAPgAAgD4AAOA+AACAPgAA4D4AAKA+AADAPgAAgD4AAMA+"},{"byteLength":96,"name":"tex_coords_gate_MY","uri":"data:application/octet-stream;base64,AACgPgAA4D4AAIA+AADgPgAAoD4AAAA/AACAPgAA4D4AAIA+AAAAPwAAoD4AAAA/AACgPgAAAD8AAKA+AADgPgAAgD4AAAA/AACAPgAAAD8AAKA+AADgPgAAgD4AAOA+"},{"byteLength":96,"name":"tex_coords_gate_M","uri":"data:application/octet-stream;base64,AACgPgAAAD8AAIA+AAAAPwAAoD4AABA/AACAPgAAAD8AAIA+AAAQPwAAoD4AABA/AACgPgAAED8AAKA+AAAAPwAAgD4AABA/AACAPgAAED8AAKA+AAAAPwAAgD4AAAA/"},{"byteLength":96,"name":"tex_coords_gate_RX","uri":"data:application/octet-stream;base64,AADAPgAAwD4AAKA+AADAPgAAwD4AAOA+AACgPgAAwD4AAKA+AADgPgAAwD4AAOA+AADAPgAA4D4AAMA+AADAPgAAoD4AAOA+AACgPgAA4D4AAMA+AADAPgAAoD4AAMA+"},{"byteLength":96,"name":"tex_coords_gate_RY","uri":"data:application/octet-stream;base64,AADAPgAA4D4AAKA+AADgPgAAwD4AAAA/AACgPgAA4D4AAKA+AAAAPwAAwD4AAAA/AADAPgAAAD8AAMA+AADgPgAAoD4AAAA/AACgPgAAAD8AAMA+AADgPgAAoD4AAOA+"},{"byteLength":96,"name":"tex_coords_gate_R","uri":"data:application/octet-stream;base64,AADAPgAAAD8AAKA+AAAAPwAAwD4AABA/AACgPgAAAD8AAKA+AAAQPwAAwD4AABA/AADAPgAAED8AAMA+AAAAPwAAoD4AABA/AACgPgAAED8AAMA+AAAAPwAAoD4AAAA/"},{"byteLength":96,"name":"tex_coords_gate_MXX","uri":"data:application/octet-stream;base64,AAAwPwAAED8AACA/AAAQPwAAMD8AACA/AAAgPwAAED8AACA/AAAgPwAAMD8AACA/AAAwPwAAID8AADA/AAAQPwAAID8AACA/AAAgPwAAID8AADA/AAAQPwAAID8AABA/"},{"byteLength":96,"name":"tex_coords_gate_MYY","uri":"data:application/octet-stream;base64,AABAPwAAED8AADA/AAAQPwAAQD8AACA/AAAwPwAAED8AADA/AAAgPwAAQD8AACA/AABAPwAAID8AAEA/AAAQPwAAMD8AACA/AAAwPwAAID8AAEA/AAAQPwAAMD8AABA/"},{"byteLength":96,"name":"tex_coords_gate_MZZ","uri":"data:application/octet-stream;base64,AABQPwAAED8AAEA/AAAQPwAAUD8AACA/AABAPwAAED8AAEA/AAAgPwAAUD8AACA/AABQPwAAID8AAFA/AAAQPwAAQD8AACA/AABAPwAAID8AAFA/AAAQPwAAQD8AABA/"},{"byteLength":96,"name":"tex_coords_gate_MPAD","uri":"data:application/octet-stream;base64,AABgPwAAED8AAFA/AAAQPwAAYD8AACA/AABQPwAAED8AAFA/AAAgPwAAYD8AACA/AABgPwAAID8AAGA/AAAQPwAAUD8AACA/AABQPwAAID8AAGA/AAAQPwAAUD8AABA/"},{"byteLength":96,"name":"tex_coords_gate_X:REC","uri":"data:application/octet-stream;base64,AABgPwAAwD4AAFA/AADAPgAAYD8AAOA+AABQPwAAwD4AAFA/AADgPgAAYD8AAOA+AABgPwAA4D4AAGA/AADAPgAAUD8AAOA+AABQPwAA4D4AAGA/AADAPgAAUD8AAMA+"},{"byteLength":96,"name":"tex_coords_gate_Y:SWEEP","uri":"data:application/octet-stream;base64,AABwPwAA4D4AAGA/AADgPgAAcD8AAAA/AABgPwAA4D4AAGA/AAAAPwAAcD8AAAA/AABwPwAAAD8AAHA/AADgPgAAYD8AAAA/AABgPwAAAD8AAHA/AADgPgAAYD8AAOA+"},{"byteLength":96,"name":"tex_coords_gate_Z:REC","uri":"data:application/octet-stream;base64,AABgPwAAAD8AAFA/AAAAPwAAYD8AABA/AABQPwAAAD8AAFA/AAAQPwAAYD8AABA/AABgPwAAED8AAGA/AAAAPwAAUD8AABA/AABQPwAAED8AAGA/AAAAPwAAUD8AAAA/"},{"byteLength":1560,"name":"buf_scattered_lines","uri":"data:application/octet-stream;base64,AABAwAAAAMIAAADCAABQwAAAiMEAAIDBAABQwAAAiMEAAIDBAABAwAAAAMAAAACAAABAwAAAgMAAAACAAABAwAAAwMAAAACAAABAwAAAAMEAAACAAABAwAAAIMEAAACAAABAwAAAQMEAAACAAABAwAAAYMEAAACAAABAwAAAgMEAAACAAABAwAAAkMEAAACAAABAwAAAoMEAAACAAABAwAAAsMEAAACAAACAwAAAAMIAAADCAACIwAAAiMEAAIDBAACIwAAAiMEAAIDBAACAwAAAAMAAAACAAACAwAAAgMAAAACAAACAwAAAwMAAAACAAACAwAAAAMEAAACAAACAwAAAIMEAAACAAACAwAAAQMEAAACAAACAwAAAYMEAAACAAACAwAAAgMEAAACAAACAwAAAkMEAAACAAACAwAAAoMEAAACAAACAwAAAsMEAAACAAACgwAAAAMIAAADCAACowAAAiMEAAIDBAACowAAAiMEAAIDBAACgwAAAAMAAAACAAACgwAAAgMAAAACAAACgwAAAwMAAAACAAACgwAAAAMEAAACAAACgwAAAIMEAAACAAACgwAAAQMEAAACAAACgwAAAYMEAAACAAACgwAAAgMEAAACAAACgwAAAkMEAAACAAACgwAAAoMEAAACAAACgwAAAsMEAAACAAACgwAAAwMEAAACAAACgwAAA0MEAAACAAACgwAAA4MEAAACAAACgwAAA8MEAAACAAACgwAAAAMIAAACAAACgwAAACMIAAACAAADAwAAAgMAAAACAAADAwAAAAMAAAACAAADAwAAAwMAAAACAAADAwAAAgMAAAACAAADAwAAAYMEAAACAAADIwAAAMMEAAACAAADIwAAAMMEAAACAAADAwAAAAMEAAACAAADAwAAAQMEAAACAAADAwAAAYMEAAACAAADgwAAAAMAAAACAAADgwAAAgMAAAACAAADgwAAAAMEAAACAAADgwAAAIMEAAACAAAAQwQAAAMAAAACAAAAUwQAAiMEAAIDBAAAUwQAAiMEAAIDBAAAQwQAAAMIAAADCAAAQwQAAgMAAAACAAAAQwQAAAMAAAACAAAAgwQAAAMAAAACAAAAkwQAAiMEAAIDBAAAkwQAAiMEAAIDBAAAgwQAAAMIAAADCAABAwQAAAMIAAADCAABEwQAAiMEAAIDBAABEwQAAiMEAAIDBAABAwQAAAMAAAACAAABAwQAAgMAAAACAAABAwQAAwMAAAACAAABAwQAAAMEAAACAAABAwQAAIMEAAACAAABAwQAAQMEAAACAAABAwQAAYMEAAACAAABwwQAAAMIAAADCAAB0wQAAiMEAAIDBAAB0wQAAiMEAAIDBAABwwQAAAMAAAACAAADAwQAAgMAAAACAAADAwQAAwMAAAACAAADAwQAAAMEAAACAAADAwQAAIMEAAACAAADAwQAAYMEAAACAAADAwQAAQMEAAACAAADAwQAAgMEAAACAAADAwQAAYMEAAACAAACAPwAAAMIAAADCAADQwQAAAMIAAADCAACAPwAAAMAAAACAAADQwQAAAMAAAACAAACAPwAAgMAAAACAAADQwQAAgMAAAACAAACAPwAAwMAAAACAAADQwQAAwMAAAACAAACAPwAAAMEAAACAAADQwQAAAMEAAACAAACAPwAAIMEAAACAAADQwQAAIMEAAACAAACAPwAAQMEAAACAAADQwQAAQMEAAACAAACAPwAAYMEAAACAAADQwQAAYMEAAACAAACAPwAAgMEAAACAAADQwQAAgMEAAACAAACAPwAAkMEAAACAAADQwQAAkMEAAACAAACAPwAAoMEAAACAAADQwQAAoMEAAACAAACAPwAAsMEAAACAAADQwQAAsMEAAACAAACAPwAAwMEAAACAAADQwQAAwMEAAACAAACAPwAA0MEAAACAAADQwQAA0MEAAACAAACAPwAA4MEAAACAAADQwQAA4MEAAACAAACAPwAA8MEAAACAAADQwQAA8MEAAACAAACAPwAAAMIAAACAAADQwQAAAMIAAACAAACAPwAACMIAAACAAADQwQAACMIAAACA"},{"byteLength":360,"name":"buf_red_scattered_lines","uri":"data:application/octet-stream;base64,AAAAAAAAAIAAAIDBAABAwAAAAIAAAIDBAAAgwAAAAL8AAIDBAABAwAAAAIAAAIDBAAAgwAAAAD8AAIDBAABAwAAAAIAAAIDBAABcwQAAgL8AAIA/AABcwQAAgL8AAATCAABcwQAAgL8AAIA/AABcwQAADMIAAIA/AABcwQAAgL8AAIA/AACKwQAAgL8AAIA/AABcwQAAgL8AAATCAABcwQAADMIAAATCAABcwQAAgL8AAATCAACKwQAAgL8AAATCAABcwQAADMIAAIA/AABcwQAADMIAAATCAABcwQAADMIAAIA/AACKwQAADMIAAIA/AABcwQAADMIAAATCAACKwQAADMIAAATCAACKwQAAgL8AAIA/AACKwQAAgL8AAATCAACKwQAAgL8AAIA/AACKwQAADMIAAIA/AACKwQAAgL8AAATCAACKwQAADMIAAATCAACKwQAADMIAAIA/AACKwQAADMIAAATC"},{"byteLength":1152,"name":"buf_blue_scattered_lines","uri":"data:application/octet-stream;base64,AABAv83MzL8AAAA/AABAv5qZmb8AAAA/AABAv83MzL8AAALCAABAv5qZmb8AAALCAABAv5qZmb8AAAA/AABAv5qZmb8AAALCAABAv5qZmb8AAAA/AAAQwJqZmb8AAAA/AABAv5qZmb8AAALCAAAQwJqZmb8AAALCAAAQwM3MzL8AAAA/AAAQwJqZmb8AAAA/AAAQwM3MzL8AAALCAAAQwJqZmb8AAALCAAAQwJqZmb8AAAA/AAAQwJqZmb8AAALCAAAwwM3MzL8AAAA/AAAwwJqZmb8AAAA/AAAwwM3MzL8AAALCAAAwwJqZmb8AAALCAAAwwJqZmb8AAAA/AAAwwJqZmb8AAALCAAAwwJqZmb8AAAA/AACowJqZmb8AAAA/AAAwwJqZmb8AAALCAACowJqZmb8AAALCAACowM3MzL8AAAA/AACowJqZmb8AAAA/AACowM3MzL8AAALCAACowJqZmb8AAALCAACowJqZmb8AAAA/AACowJqZmb8AAALCAAC4wM3MzL8AAAA/AAC4wJqZmb8AAAA/AAC4wM3MzL8AAALCAAC4wJqZmb8AAALCAAC4wJqZmb8AAAA/AAC4wJqZmb8AAALCAAC4wJqZmb8AAAA/AAAEwZqZmb8AAAA/AAC4wJqZmb8AAALCAAAEwZqZmb8AAALCAAAEwc3MzL8AAAA/AAAEwZqZmb8AAAA/AAAEwc3MzL8AAALCAAAEwZqZmb8AAALCAAAEwZqZmb8AAAA/AAAEwZqZmb8AAALCAAAMwc3MzL8AAAA/AAAMwZqZmb8AAAA/AAAMwc3MzL8AAALCAAAMwZqZmb8AAALCAAAMwZqZmb8AAAA/AAAMwZqZmb8AAALCAAAMwZqZmb8AAAA/AAA0wZqZmb8AAAA/AAAMwZqZmb8AAALCAAA0wZqZmb8AAALCAAA0wc3MzL8AAAA/AAA0wZqZmb8AAAA/AAA0wc3MzL8AAALCAAA0wZqZmb8AAALCAAA0wZqZmb8AAAA/AAA0wZqZmb8AAALCAABcwc3MzL8AAAA/AABcwZqZmb8AAAA/AABcwc3MzL8AAALCAABcwZqZmb8AAALCAABcwZqZmb8AAAA/AABcwZqZmb8AAALCAABcwZqZmb8AAAA/AACCwZqZmb8AAAA/AABcwZqZmb8AAALCAACCwZqZmb8AAALCAACCwc3MzL8AAAA/AACCwZqZmb8AAAA/AACCwc3MzL8AAALCAACCwZqZmb8AAALCAACCwZqZmb8AAAA/AACCwZqZmb8AAALCAACWwc3MzL8AAAA/AACWwZqZmb8AAAA/AACWwc3MzL8AAALCAACWwZqZmb8AAALCAACWwZqZmb8AAAA/AACWwZqZmb8AAALCAACWwZqZmb8AAAA/AAC6wZqZmb8AAAA/AACWwZqZmb8AAALCAAC6wZqZmb8AAALCAAC6wc3MzL8AAAA/AAC6wZqZmb8AAAA/AAC6wc3MzL8AAALCAAC6wZqZmb8AAALCAAC6wZqZmb8AAAA/AAC6wZqZmb8AAALC"}],"images":[{"name":"gates_image","uri":"data:image/png;base64,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"}],"materials":[{"doubleSided":false,"name":"gates_material","pbrMetallicRoughness":{"baseColorFactor":[1,1,1,1],"baseColorTexture":{"index":0,"texCoord":0},"metallicFactor":0.4,"roughnessFactor":0.5}},{"doubleSided":true,"name":"black","pbrMetallicRoughness":{"baseColorFactor":[0,0,0,1],"metallicFactor":1,"roughnessFactor":1}},{"doubleSided":true,"name":"white","pbrMetallicRoughness":{"baseColorFactor":[1,1,1,1],"metallicFactor":0.4,"roughnessFactor":0.5}},{"doubleSided":true,"name":"white","pbrMetallicRoughness":{"baseColorFactor":[1,1,1,1],"metallicFactor":0.4,"roughnessFactor":0.5}},{"doubleSided":true,"name":"black","pbrMetallicRoughness":{"baseColorFactor":[0,0,0,1],"metallicFactor":1,"roughnessFactor":1}},{"doubleSided":true,"name":"white","pbrMetallicRoughness":{"baseColorFactor":[1,1,1,1],"metallicFactor":0.4,"roughnessFactor":0.5}},{"doubleSided":true,"name":"black","pbrMetallicRoughness":{"baseColorFactor":[0,0,0,1],"metallicFactor":1,"roughnessFactor":1}},{"doubleSided":true,"name":"black","pbrMetallicRoughness":{"baseColorFactor":[0,0,0,1],"metallicFactor":1,"roughnessFactor":1}},{"doubleSided":true,"name":"gray","pbrMetallicRoughness":{"baseColorFactor":[0.5,0.5,0.5,1],"metallicFactor":1,"roughnessFactor":1}},{"doubleSided":true,"name":"black","pbrMetallicRoughness":{"baseColorFactor":[0,0,0,1],"metallicFactor":1,"roughnessFactor":1}},{"doubleSided":true,"name":"black","pbrMetallicRoughness":{"baseColorFactor":[0,0,0,1],"metallicFactor":1,"roughnessFactor":1}},{"doubleSided":true,"name":"red","pbrMetallicRoughness":{"baseColorFactor":[1,0,0,1],"metallicFactor":1,"roughnessFactor":1}},{"doubleSided":true,"name":"blue","pbrMetallicRoughness":{"baseColorFactor":[0,0,1,1],"metallicFactor":1,"roughnessFactor":1}}],"meshes":[{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":1},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":2},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":3},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":4},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":5},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":6},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":7},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":8},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":9},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":10},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":11},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":12},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":13},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":14},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":15},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":16},"material":1,"mode":6},{"attributes":{"POSITION":17},"material":2,"mode":1}]},{"primitives":[{"attributes":{"POSITION":18},"material":3,"mode":6},{"attributes":{"POSITION":18},"material":4,"mode":3},{"attributes":{"POSITION":19},"material":4,"mode":1}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":20},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":21},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":22},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":23},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":24},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":25},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":26},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":27},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":28},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":29},"material":5,"mode":6},{"attributes":{"POSITION":29},"material":6,"mode":3},{"attributes":{"POSITION":30},"material":6,"mode":1}]},{"primitives":[{"attributes":{"POSITION":31},"material":7,"mode":2},{"attributes":{"POSITION":31},"material":8,"mode":4}]},{"primitives":[{"attributes":{"POSITION":32},"material":9,"mode":6}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":33},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":34},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":35},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":36},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":37},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":38},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":39},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":40},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":41},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":42},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":43},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":44},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":45},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":46},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":47},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":48},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":49},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":50},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":51},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":52},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":53},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":54},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":55},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":56},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":57},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":58},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":59},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":60},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":61},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":62},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":63},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":64},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":65},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":0,"TEXCOORD_0":66},"material":0,"mode":4}]},{"primitives":[{"attributes":{"POSITION":67},"material":10,"mode":1}]},{"primitives":[{"attributes":{"POSITION":68},"material":11,"mode":1}]},{"primitives":[{"attributes":{"POSITION":69},"material":12,"mode":1}]}],"nodes":[{"mesh":0,"translation":[-0,-32,-32]},{"mesh":1,"translation":[-0,-2,-0]},{"mesh":2,"translation":[-0,-4,-0]},{"mesh":3,"translation":[-0,-6,-0]},{"mesh":4,"translation":[-1,-32,-32]},{"mesh":5,"translation":[-1,-2,-0]},{"mesh":6,"translation":[-1,-4,-0]},{"mesh":7,"translation":[-1,-6,-0]},{"mesh":8,"translation":[-1,-8,-0]},{"mesh":9,"translation":[-2,-32,-32]},{"mesh":10,"translation":[-2,-2,-0]},{"mesh":11,"translation":[-2,-4,-0]},{"mesh":12,"translation":[-2,-6,-0]},{"mesh":13,"translation":[-2,-8,-0]},{"mesh":14,"translation":[-2,-10,-0]},{"mesh":15,"translation":[-3,-32,-32]},{"mesh":16,"translation":[-3,-2,-0]},{"mesh":17,"translation":[-3,-4,-0]},{"mesh":17,"translation":[-3,-6,-0]},{"mesh":18,"translation":[-3,-8,-0]},{"mesh":18,"translation":[-3,-10,-0]},{"mesh":19,"translation":[-3,-12,-0]},{"mesh":19,"translation":[-3,-14,-0]},{"mesh":16,"translation":[-3,-16,-0]},{"mesh":15,"translation":[-3,-18,-0]},{"mesh":15,"translation":[-3,-20,-0]},{"mesh":15,"translation":[-3,-22,-0]},{"mesh":20,"translation":[-4,-32,-32]},{"mesh":20,"translation":[-4,-2,-0]},{"mesh":21,"translation":[-4,-4,-0]},{"mesh":21,"translation":[-4,-6,-0]},{"mesh":22,"translation":[-4,-8,-0]},{"mesh":22,"translation":[-4,-10,-0]},{"mesh":23,"translation":[-4,-12,-0]},{"mesh":23,"translation":[-4,-14,-0]},{"mesh":24,"translation":[-4,-16,-0]},{"mesh":24,"translation":[-4,-18,-0]},{"mesh":25,"translation":[-4,-20,-0]},{"mesh":25,"translation":[-4,-22,-0]},{"mesh":26,"translation":[-5,-32,-32]},{"mesh":26,"translation":[-5,-2,-0]},{"mesh":26,"translation":[-5,-4,-0]},{"mesh":27,"translation":[-5,-6,-0]},{"mesh":26,"translation":[-5,-8,-0]},{"mesh":28,"translation":[-5,-10,-0]},{"mesh":27,"translation":[-5,-12,-0]},{"mesh":26,"translation":[-5,-14,-0]},{"mesh":27,"translation":[-5,-16,-0]},{"mesh":27,"translation":[-5,-18,-0]},{"mesh":27,"translation":[-5,-20,-0]},{"mesh":28,"translation":[-5,-22,-0]},{"mesh":28,"translation":[-5,-24,-0]},{"mesh":26,"translation":[-5,-26,-0]},{"mesh":28,"translation":[-5,-28,-0]},{"mesh":27,"translation":[-5,-30,-0]},{"mesh":28,"translation":[-5,-32,-0]},{"mesh":28,"translation":[-5,-34,-0]},{"mesh":29,"translation":[-6,-2,-0]},{"mesh":30,"translation":[-6,-4,-0]},{"mesh":31,"translation":[-6,-6,-0]},{"mesh":32,"translation":[-6,-8,-0]},{"mesh":33,"translation":[-6,-14,-0]},{"mesh":34,"translation":[-6,-12,-0]},{"mesh":35,"translation":[-6,-32,-32]},{"mesh":36,"translation":[-7,-2,-0]},{"mesh":36,"translation":[-7,-4,-0]},{"mesh":37,"translation":[-7,-6,-0]},{"mesh":38,"translation":[-7,-8,-0]},{"mesh":38,"translation":[-7,-10,-0]},{"mesh":39,"translation":[-7,-32,-32]},{"mesh":40,"translation":[-8,-2,-0]},{"mesh":41,"translation":[-8,-4,-0]},{"mesh":42,"translation":[-8,-6,-0]},{"mesh":43,"translation":[-8,-12,-0]},{"mesh":44,"translation":[-9,-32,-32]},{"mesh":45,"translation":[-9,-2,-0]},{"mesh":46,"translation":[-9,-4,-0]},{"mesh":46,"translation":[-10,-32,-32]},{"mesh":46,"translation":[-10,-2,-0]},{"mesh":47,"translation":[-11,-32,-32]},{"mesh":48,"translation":[-11,-2,-0]},{"mesh":49,"translation":[-11,-4,-0]},{"mesh":50,"translation":[-11,-6,-0]},{"mesh":51,"translation":[-11,-8,-0]},{"mesh":52,"translation":[-11,-10,-0]},{"mesh":52,"translation":[-11,-12,-0]},{"mesh":53,"translation":[-11,-14,-0]},{"mesh":54,"translation":[-11,-16,-0]},{"mesh":55,"translation":[-11,-18,-0]},{"mesh":56,"translation":[-12,-32,-32]},{"mesh":56,"translation":[-12,-2,-0]},{"mesh":56,"translation":[-12,-4,-0]},{"mesh":56,"translation":[-12,-6,-0]},{"mesh":57,"translation":[-12,-8,-0]},{"mesh":57,"translation":[-12,-10,-0]},{"mesh":58,"translation":[-12,-12,-0]},{"mesh":58,"translation":[-12,-14,-0]},{"mesh":7,"translation":[-14,-32,-32]},{"mesh":28,"translation":[-15,-32,-32]},{"mesh":26,"translation":[-15,-2,-0]},{"mesh":13,"translation":[-16,-2,-0]},{"mesh":49,"translation":[-19,-32,-32]},{"mesh":39,"translation":[-20,-32,-32]},{"mesh":49,"translation":[-21,-32,-32]},{"mesh":59,"translation":[-22,-32,-32]},{"mesh":59,"translation":[-22,-2,-0]},{"mesh":59,"translation":[-23,-32,-32]},{"mesh":47,"translation":[-24,-32,-32]},{"mesh":51,"translation":[-24,-2,-0]},{"mesh":58,"translation":[-24,-4,-0]},{"mesh":58,"translation":[-24,-6,-0]},{"mesh":57,"translation":[-24,-8,-0]},{"mesh":57,"translation":[-24,-10,-0]},{"mesh":44,"translation":[-24,-12,-0]},{"mesh":45,"translation":[-24,-14,-0]},{"mesh":46,"translation":[-24,-16,-0]},{"mesh":60,"translation":[-25,-32,-32]},{"mesh":61,"translation":[-25,-2,-0]},{"mesh":62,"translation":[-25,-4,-0]},{"mesh":63,"translation":[0,0,0]},{"mesh":64,"translation":[0,0,0]},{"mesh":65,"translation":[0,0,0]}],"samplers":[{"magFilter":9728,"minFilter":9728,"wrapS":33071,"wrapT":33071}],"scene":0,"scenes":[{"nodes":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121]}],"textures":[{"name":"gates_texture","sampler":0,"source":0}]} \ No newline at end of file diff --git a/testdata/circuit_all_ops_detslice.svg b/testdata/circuit_all_ops_detslice.svg index d96f0bf5b..8d5706f6e 100644 --- a/testdata/circuit_all_ops_detslice.svg +++ b/testdata/circuit_all_ops_detslice.svg @@ -290,6 +290,11 @@ + + + + + √XX diff --git a/testdata/circuit_all_ops_timeline.svg b/testdata/circuit_all_ops_timeline.svg index 70b707457..1c9563c2f 100644 --- a/testdata/circuit_all_ops_timeline.svg +++ b/testdata/circuit_all_ops_timeline.svg @@ -98,6 +98,11 @@ + + + + + √XX diff --git a/testdata/circuit_all_ops_timeslice.svg b/testdata/circuit_all_ops_timeslice.svg index d96f0bf5b..8d5706f6e 100644 --- a/testdata/circuit_all_ops_timeslice.svg +++ b/testdata/circuit_all_ops_timeslice.svg @@ -290,6 +290,11 @@ + + + + + √XX