# The `BitSlice` Type
## Introduction
A [`BitSlice`] is a vector-like, non-owning _view_ into a non-empty range of bits.
The bits are compactly stored somewhere else in unsigned integer words.
The default word type is `usize`.
Bit-slices are typically created by borrowing a contiguous range of bits from a [`BitVector`] or a [`BitArray`] using the [`BitStore::slice`] or [`BitStore::slice_mut`] methods.
The type implements the [`BitStore`] trait, which provides a rich API for manipulating the bits in the vector.
This means that bit-slices can be used anywhere a bit-store is expected.
It also means that you can take slices of slices.
### Notes
- A `BitSlice` can only live as long as the underlying store of words exists so has a lifetime parameter.
- The bits in a bit-slice are not necessarily aligned to the word-boundaries of the underlying word store. However, the slice will _synthesize_ appropriate `Unsigned` words from the underlying store as needed.
## Methods Overview
The `BitSlice` type implements the [`BitStore`] trait and has methods for constructing bit-slices:
| Category | Description |
| ----------------------------------------- | ---------------------------------------------------------------- |
| [Trait Requirements](#trait-requirements) | Methods needed to implement the [`BitStore`] trait. |
| [Constructors](#constructors) | Methods to create bit-slices with specific properties and fills. |
The type also inherits dozens of associated methods from the [`BitStore`] trait.
These methods fall into categories:
| Inherited Category | Description |
| ----------------------------------------------------- | ----------------------------------------------------------------------------------- |
| [Bit Access](BitStore#bit-access) | Methods to access individual bit elements in a bit-slice. |
| [Queries](BitStore#queries) | Methods to query the overall state of a bit-slice. |
| [Mutators](BitStore#mutators) | Methods to mutate the overall state of a bit-slice. |
| [Copies & Fills](BitStore#copies-and-fills) | Methods to fill a bit-slice from various sources. |
| [Slices](BitStore#slices) | Methods to create non-owning views over a part of a bit-slice --- _bit-sub-slices_. |
| [Sub-vectors](BitStore#sub-vectors) | Methods to clone a piece of a bit-slice as a new bit-vector. |
| [Riffling](BitStore#riffling) | Methods to create vectors that copy a bit-slice with interleaved zeros. |
| [Set/Unset Indices](BitStore#indices) | Methods to find the indices of set & unset bits in a bit-slice. |
| [Iterators](BitStore#iterators) | Methods to create various iterators over a bit-slice. |
| [Stringification](#stringification) | Methods to create string representations of a bit-slice. |
| [Bit Shifts](BitStore#shifts) | Methods to shift the bits in a bit-slice left or right. |
| [Bitwise Operations](BitStore#bit-wise-operations) | Methods to combine any bit-store and a bit-slice using logical operations. |
| [Arithmetic Operators](BitStore#arithmetic-operators) | Methods to add or subtract any bit-store and a bit-slice. |
| [Other Functions](BitStore#other-functions) | Dot products, convolutions, etc. for bit-stores with bit-slices. |
## Trait Requirements
To implement the [`BitStore`] trait, the type defines the following seven methods:
| Method | Description |
| ----------------------- | ------------------------------------------------------------------------------------ |
| [`BitSlice::len`] | Returns the number of bits in the bit-slice. |
| [`BitSlice::store`] | Provides read-only access to the first _word_ holding bits in the bit-slice. |
| [`BitSlice::store_mut`] | Provides read-write access to the first _word_ holding bits in the bit-slice. |
| [`BitSlice::offset`] | Returns the offset in bits from start of `word(0)` to the bit-slice's first element. |
| [`BitSlice::words`] | This is always `Word::words_needed(self.len())` but cached for efficiency. |
| [`BitSlice::word`] | Returns a "word" from the bit-slice. |
| [`BitSlice::set_word`] | Sets the value of a "word" in the bit-slice to a passed value. |
Implementing these methods for bit-slices requires some care to ensure that the correct bits are read from or written to the underlying word store, especially when the bit-slice is not aligned to word boundaries.
For a bit-slice, the return value for `store.word(i)` will often be synthesised from two contiguous "real" words `w[j]` and `w[j+1]` for some `j`.
`store.word[i]` will use some high-order bits from `w[j]` and low-order bits from `w[j+1]`.
The following diagram shows how bits in a bit-slice lie within the underlying words, which are `u8`s in this example:
<div style="border: 2px solid #ccc; border-radius: 8px; padding: 16px; margin: 16px 0; background-color: #f9f9f9; display: flex; align-items: center; justify-content: center;">
![Embedded Figure][bit-slice-example]
</div>
o satisfy the [`BitStore`] trait, a bit-slice behaves _as if_ bits from the real underlying store were copied and shuffled down so that element zero is bit 0 of word 0 in the bit-slice. However, it never actually copies anything; instead, it synthesises "words" as needed.
The same principle applies to the `store.set_word(i, value)` method.
The implementation of `set_word` for bit-vectors and bit-arrays is trivial, with the one caveat that we have to be careful not to inadvertently touch any unoccupied bits in the final underlying word, or at least be sure to leave them as zeros.
In the case of a bit-slice, calls to `set_word(i, value)` will generally copy low-order bits from `value` into the high-order bits of some real underlying word `w[j]` and copy the rest of the high-order bits from `value` into the low-order bits of `w[j+1]`. The other bits in `w[j]` and `w[j+1]` will not be touched.
## Constructors
The `BitSlice` type has a couple of constructors.
However, bit-slices are most commonly created using the [`BitStore::slice`] and [`BitStore::slice_mut`] methods on other bit-stores.
| Method Name | Description |
| --------------------- | ------------------------------- |
| [`BitSlice::new`] | Creates a read-only bit-slice. |
| [`BitSlice::new_mut`] | Creates a read-write bit-slice. |
## Bit Access (Inherited)
The following methods provide access to individual bit elements in the bit-slice.
| Method | Description |
| ------------------- | ----------------------------------------------------------------- |
| [`BitStore::get`] | Returns the value of a single bit element as a read-only boolean. |
| [`BitStore::first`] | Returns the value of the first element in the bit-slice. |
| [`BitStore::last`] | Returns the value of the last element in the bit-slice. |
| [`BitStore::set`] | Sets a bit to the given boolean value. |
| [`BitStore::flip`] | Flips the value of the bit element at a given index. |
| [`BitStore::swap`] | Swaps the values of bit elements at locations `i` and `j`. |
## Queries (Inherited)
The following methods let you query the overall state of a bit-slice.
| Method | Description |
| ---------------------------- | ----------------------------------------------------------- |
| [`BitStore::is_empty`] | Returns true if the bit-slice is empty |
| [`BitStore::any`] | Returns true if _any_ bit in the bit-slice is set. |
| [`BitStore::all`] | Returns true if _every_ bit in the bit-slice is set. |
| [`BitStore::none`] | Returns true if _no_ bit in the bit-slice is set. |
| [`BitStore::count_ones`] | Returns the number of set bits in the bit-slice. |
| [`BitStore::count_zeros`] | Returns the number of unset bits in the bit-slice. |
| [`BitStore::leading_zeros`] | Returns the number of leading unset bits in the bit-slice. |
| [`BitStore::trailing_zeros`] | Returns the number of trailing unset bits in the bit-slice. |
## Mutators (Inherited)
The following methods let you mutate the entire bit-slice in a single call.
| Method | Description |
| ---------------------- | ----------------------------------------------------------------------------------- |
| [`BitStore::set_all`] | Sets all the bits in the bit-slice to the passed value. |
| [`BitStore::flip_all`] | Flips the values of all the bits in the bit-slice. |
| [`BitStore::flipped`] | Returns a new bit-vector that is a copy of the bit-slice with all the bits flipped. |
## Copies and Fills (Inherited)
The following methods let you populate the entire bit-slice from multiple sources in a single call.
| Method | Description |
| --------------------------------------- | ------------------------------------------------------------------------------------ |
| [`BitStore::copy_unsigned`] | Copies bit values from any unsigned value to this bit-slice. |
| [`BitStore::copy_store`] | Copies bit values from any source bit-store to this bit-slice. |
| [`BitStore::copy_fn`] | Copies bit values from a function that returns a boolean for an index. |
| [`BitStore::fill_random_biased_seeded`] | Very general method to fill the bit-slice with random 0's and 1's. |
| [`BitStore::fill_random_biased`] | Fill the bit-slice with random 0's and 1's, where the RNG it itself randomly seeded. |
| [`BitStore::fill_random`] | Fill the bit-slice with random 0's and 1's from flips of a _fair_ coin. |
## Slices (Inherited)
The following methods let you create a [`BitSlice`], which is a non-owning view of some contiguous subset of bits in the bit-slice.
| Method | Description |
| ----------------------- | ---------------------------------------------------------------------------- |
| [`BitStore::slice`] | Returns a [`BitSlice`] encompassing the bits in a half-open range. |
| [`BitStore::slice_mut`] | Returns a _mutable_ [`BitSlice`] encompassing the bits in a half-open range. |
## Sub-vectors (Inherited)
The following methods create or fill _independent_ bit-vectors with copies of some contiguous subset of the bits in the bit-slice.
| Method | Description |
| --------------------------- | ---------------------------------------------------------------------------------------- |
| [`BitStore::sub`] | Returns a new [`BitVector`] encompassing the bits in a half-open range. |
| [`BitStore::split_at_into`] | Fills two bit-vectors with the bits in the ranges `[0, at)` and `[at, len())`. |
| [`BitStore::split_at`] | Returns two new two bit-vectors with the bits in the ranges `[0, at)` and `[at, len())`. |
## Riffling (Inherited)
We have methods that can interleave (_riffle_) the bits in a bit-slice with zeros.
| Method | Description |
| -------------------------- | ------------------------------------------------------------------------------------- |
| [`BitStore::riffled_into`] | Fills a pre-existing bit-vector with the result of riffling this bit-slice. |
| [`BitStore::riffled`] | Returns a new bit-vector that is this bit-slice with its bits interleaved with zeros. |
## Set and Unset Bit Indices (Inherited)
The following methods find the indices of set or unset bits in the bit-slice.
| Method | Description |
| ---------------------------- | --------------------------------------------------------------------------------------- |
| [`BitStore::first_set`] | Returns the index of the first set bit in the bit-slice. |
| [`BitStore::last_set`] | Returns the index of the last set bit in the bit-slice. |
| [`BitStore::next_set`] | Returns the index of the next set bit in the bit-slice _after_ the passed index. |
| [`BitStore::previous_set`] | Returns the index of the previous set bit in the bit-slice _before_ the passed index. |
| [`BitStore::first_unset`] | Returns the index of the first unset bit in the bit-slice. |
| [`BitStore::last_unset`] | Returns the index of the last unset bit in the bit-slice. |
| [`BitStore::next_unset`] | Returns the index of the next unset bit in the bit-slice _after_ the passed index. |
| [`BitStore::previous_unset`] | Returns the index of the previous unset bit in the bit-slice _before_ the passed index. |
## Iterators (Inherited)
The following methods create iterators for traversing the bits or underlying words in the bit-slice:
| Method | Description |
| ------------------------- | --------------------------------------------------------------------------- |
| [`BitStore::bits`] | Returns a [`Bits`] iterator over the bits in the bit-slice. |
| [`BitStore::set_bits`] | Returns a [`SetBits`] iterator to view the indices of all the set bits. |
| [`BitStore::unset_bits`] | Returns a [`UnsetBits`] iterator to view the indices of all the unset bits. |
| [`BitStore::store_words`] | Returns a [`Words`] iterator to view the "words" underlying the bit-slice. |
| [`BitStore::to_words`] | Returns a copy of the "words" underlying the bit-slice. |
## Stringification (Inherited)
The following functions returns a string representation of a bit-slice.
The string can be in the obvious binary format or a more compact hex format.
| Method | Description |
| ------------------------------------- | --------------------------------------------------------------------------------------------- |
| [`BitStore::to_custom_binary_string`] | Returns a binary string representation for a bit-slice with various customisation parameters. |
| [`BitStore::to_binary_string`] | Returns the simplest binary string representation for a bit-slice. |
| [`BitStore::to_pretty_string`] | Returns a "pretty" binary string representation for a bit-slice. |
| [`BitStore::to_hex_string`] | Returns a compact hex string representation for a bit-slice. |
| [`std::string::ToString::to_string`] | Delegates to [`BitStore::to_binary_string`]. |
| [`BitStore::describe`] | Returns a multi-line string describing the bit-slice in some detail. |
## Bit Shifts (Inherited)
We have methods to shift the bits in a bit-slice left or right.
| Methods | Description |
| --------------------------- | ---------------------------------------------------------------------- |
| [`BitStore::left_shift`] | Left shifts in-place. |
| [`BitStore::right_shift`] | Right shifts in-place. |
| [`BitStore::left_shifted`] | Copies the bit-slice to a new bit-vector and left shifts that vector. |
| [`BitStore::right_shifted`] | Copies the bit-slice to a new bit-vector and right shifts that vector. |
**Note:** We have also implemented the [`std::ops::ShlAssign`], [`std::ops::ShrAssign`], [`std::ops::Shl`], and [`std::ops::Shr`] foreign traits to provide operator overloads for the shift operations. Those implementations forward to the associated methods above.
## Bitwise Operations (Inherited)
We have methods that combine a bit-slice with any other bit-store using the logical operations `XOR`, `AND`, and `OR`.
| Method | Description |
| -------------------- | ----------------------------------------------------------------------------------- |
| [`BitStore::xor_eq`] | In-place `XOR` operation of equal-sized bit-stores: `lhs = lhs ^ rhs`. |
| [`BitStore::and_eq`] | In-place `AND` operation of equal-sized bit-stores: `lhs = lhs & rhs`. |
| [`BitStore::or_eq`] | In-place `OR` operation of equal-sized bit-stores: `lhs = lhs \| rhs`. |
| [`BitStore::xor`] | Returns the `XOR` of this store with another equal-sized store as a new bit-vector. |
| [`BitStore::and`] | Returns the `AND` of this store with another equal-sized store as a new bit-vector. |
| [`BitStore::or`] | Returns the `OR` of this store with another equal-sized store as a new bit-vector. |
**Note:** We have also implemented the [`std::ops::BitXorAssign`], [`std::ops::BitAndAssign`], [`std::ops::BitOrAssign`], [`std::ops::BitXor`], [`std::ops::BitAnd`], and [`std::ops::BitOr`] foreign traits to provide operator overloads for the bit-wise operations. Those implementations forward to the associated methods above.
## Arithmetic Operations (Inherited)
In GF(2), the arithmetic operators `+` and `-` are both the `XOR` operator.
| Method | Description |
| ---------------------- | ---------------------------------------------------------------------------- |
| [`BitStore::plus_eq`] | Adds the passed (equal-sized) `rhs` bit-store to this bit-slice. |
| [`BitStore::minus_eq`] | Subtracts the passed (equal-sized) `rhs` bit-store from this bit-slice. |
| [`BitStore::plus`] | Adds two equal-sized bit-stores and returns the result as a bit-vector. |
| [`BitStore::minus`] | Subtracts two equal-sized bit-stores and returns the result as a bit-vector. |
**Note:** We have also implemented the [`std::ops::AddAssign`], [`std::ops::SubAssign`], [`std::ops::Add`], and [`std::ops::Sub`] foreign traits to provide operator overloads for the arithmetic operations. Those implementations forward to the associated methods above.
## Other Inherited Functions
| Method | Description |
| ---------------------------- | ------------------------------------------------------------------- |
| [`BitStore::dot`] | Returns the dot product of two equal-sized bit-stores as a boolean. |
| [`BitStore::convolved_with`] | Returns the convolution of two bit-stores as a new bit-vector. |
## Foreign Traits for Individual Bit-Arrays
We have implemented several foreign traits from the standard library for bit-vectors.
| Trait Name | Description |
| ----------------------- | -------------------------------------------- |
| [`std::ops::Index`] | Forwarded to [`BitStore::get`]. |
| [`std::ops::Not`] | Forwarded to [`BitStore::flipped`]. |
| [`std::fmt::Display`] | Forwarded to [`BitStore::to_binary_string`]. |
| [`std::fmt::Binary`] | Forwarded to [`BitStore::to_binary_string`]. |
| [`std::fmt::UpperHex`] | Forwarded to [`BitStore::to_hex_string`]. |
| [`std::fmt::LowerHex`] | Forwarded to [`BitStore::to_hex_string`]. |
| [`std::ops::ShlAssign`] | Forwarded to [`BitStore::left_shift`]. |
| [`std::ops::ShrAssign`] | Forwarded to [`BitStore::right_shift`]. |
| [`std::ops::Shl`] | Forwarded to [`BitStore::left_shifted`]. |
| [`std::ops::Shr`] | Forwarded to [`BitStore::right_shifted`]. |
The [`std::ops::Not`] trait is implemented for bit-slices by value and by reference.
## Foreign Traits for Pairwise Bit-Array Operations with Other Bit-Stores
We have implemented several foreign traits from the standard library for bit-vectors interacting with other bit-stores.
| Trait Name | Description |
| -------------------------- | ----------------------------------- |
| [`std::ops::BitXorAssign`] | Forwarded to [`BitStore::xor_eq`] |
| [`std::ops::BitAndAssign`] | Forwarded to [`BitStore::and_eq`] |
| [`std::ops::BitOrAssign`] | Forwarded to [`BitStore::or_eq`] |
| [`std::ops::AddAssign`] | Forwarded to [`BitStore::plus_eq`] |
| [`std::ops::SubAssign`] | Forwarded to [`BitStore::minus_eq`] |
| [`std::ops::BitXor`] | Forwarded to [`BitStore::xor`] |
| [`std::ops::BitAnd`] | Forwarded to [`BitStore::and`] |
| [`std::ops::BitOr`] | Forwarded to [`BitStore::or`] |
| [`std::ops::Add`] | Forwarded to [`BitStore::plus`] |
| [`std::ops::Sub`] | Forwarded to [`BitStore::minus`] |
| [`std::ops::Mul`] | Forwarded to [`BitStore::dot`] |
<!-- Internal Reference Links -->
[`BitArray`]: crate::BitArray
[`BitVector`]: crate::BitVector
[`BitSlice`]: crate::BitSlice
[`Unsigned`]: crate::Unsigned
[`Bits`]: crate::Bits
[`SetBits`]: crate::SetBits
[`UnsetBits`]: crate::UnsetBits
[`Words`]: crate::Words
<!-- External Reference Links -->
[GF(2)]: https://en.wikipedia.org/wiki/Finite_field_arithmetic
[Galois-Field]: https://en.wikipedia.org/wiki/Finite_field
<!-- Base64 Encoded Image: rustdoc is extremely primitive and cannot embed images in any reasonable manner -->
[bit-slice-example]: data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:xl="http://www.w3.org/1999/xlink" xmlns="http://www.w3.org/2000/svg" version="1.1" viewBox="45.5 388.552 763.5 131.5402" width="763.5" height="131.5402">
  <defs/>
  <g id="Canvas_1" fill-opacity="1" stroke="none" stroke-opacity="1" stroke-dasharray="none" fill="none">
    <title>Canvas 1</title>
    <g id="Canvas_1_Layer_1">
      <title>Layer 1</title>
      <g id="Graphic_108">
        <rect x="616" y="466.6442" width="19" height="25" fill="white"/>
        <rect x="616" y="466.6442" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(621 469.92826)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".34" y="15" xml:space="preserve">X</tspan>
        </text>
      </g>
      <g id="Graphic_109">
        <rect x="635" y="466.6442" width="19" height="25" fill="white"/>
        <rect x="635" y="466.6442" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(640 469.92826)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".34" y="15" xml:space="preserve">X</tspan>
        </text>
      </g>
      <g id="Graphic_110">
        <rect x="654" y="466.6442" width="19" height="25" fill="white"/>
        <rect x="654" y="466.6442" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(659 469.92826)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".34" y="15" xml:space="preserve">X</tspan>
        </text>
      </g>
      <g id="Graphic_111">
        <rect x="673" y="466.6442" width="19" height="25" fill="white"/>
        <rect x="673" y="466.6442" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(678 469.92826)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".34" y="15" xml:space="preserve">X</tspan>
        </text>
      </g>
      <g id="Graphic_36">
        <rect x="198" y="417" width="19" height="25" fill="#c0ffc0"/>
        <rect x="198" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(203 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">0</tspan>
        </text>
      </g>
      <g id="Graphic_37">
        <rect x="217" y="417" width="19" height="25" fill="#c0ffc0"/>
        <rect x="217" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(222 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">1</tspan>
        </text>
      </g>
      <g id="Graphic_38">
        <rect x="236" y="417" width="19" height="25" fill="#80ff80"/>
        <rect x="236" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(241 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">2</tspan>
        </text>
      </g>
      <g id="Graphic_39">
        <rect x="255" y="417" width="19" height="25" fill="#80ff80"/>
        <rect x="255" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(260 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">3</tspan>
        </text>
      </g>
      <g id="Graphic_43">
        <rect x="274" y="417" width="19" height="25" fill="#80ff80"/>
        <rect x="274" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(279 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">4</tspan>
        </text>
      </g>
      <g id="Graphic_42">
        <rect x="293" y="417" width="19" height="25" fill="#80ff80"/>
        <rect x="293" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(298 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">5</tspan>
        </text>
      </g>
      <g id="Graphic_41">
        <rect x="312" y="417" width="19" height="25" fill="#80ff80"/>
        <rect x="312" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(317 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">6</tspan>
        </text>
      </g>
      <g id="Graphic_40">
        <rect x="331" y="417" width="19" height="25" fill="#80ff80"/>
        <rect x="331" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(336 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">7</tspan>
        </text>
      </g>
      <g id="Graphic_51">
        <rect x="350" y="417" width="19" height="25" fill="#80ff80"/>
        <rect x="350" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(355 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">0</tspan>
        </text>
      </g>
      <g id="Graphic_50">
        <rect x="369" y="417" width="19" height="25" fill="#80ff80"/>
        <rect x="369" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(374 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">1</tspan>
        </text>
      </g>
      <g id="Graphic_49">
        <rect x="388" y="417" width="19" height="25" fill="#80ff80"/>
        <rect x="388" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(393 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">2</tspan>
        </text>
      </g>
      <g id="Graphic_48">
        <rect x="407" y="417" width="19" height="25" fill="#80ff80"/>
        <rect x="407" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(412 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">3</tspan>
        </text>
      </g>
      <g id="Graphic_47">
        <rect x="426" y="417" width="19" height="25" fill="#80ff80"/>
        <rect x="426" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(431 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">4</tspan>
        </text>
      </g>
      <g id="Graphic_46">
        <rect x="445" y="417" width="19" height="25" fill="#80ff80"/>
        <rect x="445" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(450 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">5</tspan>
        </text>
      </g>
      <g id="Graphic_45">
        <rect x="464" y="417" width="19" height="25" fill="#80ff80"/>
        <rect x="464" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(469 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">6</tspan>
        </text>
      </g>
      <g id="Graphic_44">
        <rect x="483" y="417" width="19" height="25" fill="#80ff80"/>
        <rect x="483" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(488 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">7</tspan>
        </text>
      </g>
      <g id="Graphic_59">
        <rect x="502" y="417" width="19" height="25" fill="#80ff80"/>
        <rect x="502" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(507 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">0</tspan>
        </text>
      </g>
      <g id="Graphic_58">
        <rect x="521" y="417" width="19" height="25" fill="#80ff80"/>
        <rect x="521" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(526 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">1</tspan>
        </text>
      </g>
      <g id="Graphic_57">
        <rect x="540" y="417" width="19" height="25" fill="#80ff80"/>
        <rect x="540" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(545 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">2</tspan>
        </text>
      </g>
      <g id="Graphic_56">
        <rect x="559" y="417" width="19" height="25" fill="#80ff80"/>
        <rect x="559" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(564 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">3</tspan>
        </text>
      </g>
      <g id="Graphic_55">
        <rect x="578" y="417" width="19" height="25" fill="#80ff80"/>
        <rect x="578" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(583 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">4</tspan>
        </text>
      </g>
      <g id="Graphic_54">
        <rect x="597" y="417" width="19" height="25" fill="#80ff80"/>
        <rect x="597" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(602 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">5</tspan>
        </text>
      </g>
      <g id="Graphic_53">
        <rect x="616" y="417" width="19" height="25" fill="#c0ffc0"/>
        <rect x="616" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(621 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">6</tspan>
        </text>
      </g>
      <g id="Graphic_52">
        <rect x="635" y="417" width="19" height="25" fill="#c0ffc0"/>
        <rect x="635" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(640 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">7</tspan>
        </text>
      </g>
      <g id="Graphic_67">
        <rect x="654" y="417" width="19" height="25" fill="#c0ffc0"/>
        <rect x="654" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(659 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">0</tspan>
        </text>
      </g>
      <g id="Graphic_66">
        <rect x="673" y="417" width="19" height="25" fill="#c0ffc0"/>
        <rect x="673" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(678 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">1</tspan>
        </text>
      </g>
      <g id="Graphic_65">
        <rect x="692" y="417" width="19" height="25" fill="#c0ffc0"/>
        <rect x="692" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(697 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">2</tspan>
        </text>
      </g>
      <g id="Graphic_64">
        <rect x="711" y="417" width="19" height="25" fill="#c0ffc0"/>
        <rect x="711" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(716 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">3</tspan>
        </text>
      </g>
      <g id="Graphic_63">
        <rect x="730" y="417" width="19" height="25" fill="#c0ffc0"/>
        <rect x="730" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(735 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">4</tspan>
        </text>
      </g>
      <g id="Graphic_62">
        <rect x="749" y="417" width="19" height="25" fill="#c0ffc0"/>
        <rect x="749" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(754 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">5</tspan>
        </text>
      </g>
      <g id="Graphic_61">
        <rect x="768" y="417" width="19" height="25" fill="#c0ffc0"/>
        <rect x="768" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(773 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">6</tspan>
        </text>
      </g>
      <g id="Graphic_60">
        <rect x="787" y="417" width="19" height="25" fill="#c0ffc0"/>
        <rect x="787" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(792 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">7</tspan>
        </text>
      </g>
      <g id="Graphic_75">
        <rect x="46" y="417" width="19" height="25" fill="#c0ffc0"/>
        <rect x="46" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(51 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">0</tspan>
        </text>
      </g>
      <g id="Graphic_74">
        <rect x="65" y="417" width="19" height="25" fill="#c0ffc0"/>
        <rect x="65" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(70 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">1</tspan>
        </text>
      </g>
      <g id="Graphic_73">
        <rect x="84" y="417" width="19" height="25" fill="#c0ffc0"/>
        <rect x="84" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(89 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">2</tspan>
        </text>
      </g>
      <g id="Graphic_72">
        <rect x="103" y="417" width="19" height="25" fill="#c0ffc0"/>
        <rect x="103" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(108 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">3</tspan>
        </text>
      </g>
      <g id="Graphic_71">
        <rect x="122" y="417" width="19" height="25" fill="#c0ffc0"/>
        <rect x="122" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(127 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">4</tspan>
        </text>
      </g>
      <g id="Graphic_70">
        <rect x="141" y="417" width="19" height="25" fill="#c0ffc0"/>
        <rect x="141" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(146 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">5</tspan>
        </text>
      </g>
      <g id="Graphic_69">
        <rect x="160" y="417" width="19" height="25" fill="#c0ffc0"/>
        <rect x="160" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(165 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">6</tspan>
        </text>
      </g>
      <g id="Graphic_68">
        <rect x="179" y="417" width="19" height="25" fill="#c0ffc0"/>
        <rect x="179" y="417" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(184 420.276)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">7</tspan>
        </text>
      </g>
      <g id="Graphic_84">
        <rect x="236" y="466.6442" width="19" height="25" fill="#c0c0ff"/>
        <rect x="236" y="466.6442" width="19" height="25" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(241 469.9202)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">0</tspan>
        </text>
      </g>
      <g id="Graphic_83">
        <rect x="255" y="466.6442" width="19" height="25" fill="#c0c0ff"/>
        <rect x="255" y="466.6442" width="19" height="25" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(260 469.9202)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">1</tspan>
        </text>
      </g>
      <g id="Graphic_82">
        <rect x="274" y="466.6442" width="19" height="25" fill="#c0c0ff"/>
        <rect x="274" y="466.6442" width="19" height="25" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(279 469.9202)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">2</tspan>
        </text>
      </g>
      <g id="Graphic_81">
        <rect x="293" y="466.6442" width="19" height="25" fill="#c0c0ff"/>
        <rect x="293" y="466.6442" width="19" height="25" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(298 469.9202)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">3</tspan>
        </text>
      </g>
      <g id="Graphic_80">
        <rect x="312" y="466.6442" width="19" height="25" fill="#c0c0ff"/>
        <rect x="312" y="466.6442" width="19" height="25" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(317 469.9202)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">4</tspan>
        </text>
      </g>
      <g id="Graphic_79">
        <rect x="331" y="466.6442" width="19" height="25" fill="#c0c0ff"/>
        <rect x="331" y="466.6442" width="19" height="25" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(336 469.9202)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">5</tspan>
        </text>
      </g>
      <g id="Graphic_78">
        <rect x="350" y="466.6442" width="19" height="25" fill="#c0c0ff"/>
        <rect x="350" y="466.6442" width="19" height="25" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(355 469.9202)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">6</tspan>
        </text>
      </g>
      <g id="Graphic_77">
        <rect x="369" y="466.6442" width="19" height="25" fill="#c0c0ff"/>
        <rect x="369" y="466.6442" width="19" height="25" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(374 469.9202)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">7</tspan>
        </text>
      </g>
      <g id="Graphic_92">
        <rect x="388" y="466.6442" width="19" height="25" fill="#c0c0ff"/>
        <rect x="388" y="466.6442" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(393 469.9202)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">0</tspan>
        </text>
      </g>
      <g id="Graphic_91">
        <rect x="407" y="466.6442" width="19" height="25" fill="#c0c0ff"/>
        <rect x="407" y="466.6442" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(412 469.9202)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">1</tspan>
        </text>
      </g>
      <g id="Graphic_90">
        <rect x="426" y="466.6442" width="19" height="25" fill="#c0c0ff"/>
        <rect x="426" y="466.6442" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(431 469.9202)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">2</tspan>
        </text>
      </g>
      <g id="Graphic_89">
        <rect x="445" y="466.6442" width="19" height="25" fill="#c0c0ff"/>
        <rect x="445" y="466.6442" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(450 469.9202)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">3</tspan>
        </text>
      </g>
      <g id="Graphic_88">
        <rect x="464" y="466.6442" width="19" height="25" fill="#c0c0ff"/>
        <rect x="464" y="466.6442" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(469 469.9202)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">4</tspan>
        </text>
      </g>
      <g id="Graphic_87">
        <rect x="483" y="466.6442" width="19" height="25" fill="#c0c0ff"/>
        <rect x="483" y="466.6442" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(488 469.9202)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">5</tspan>
        </text>
      </g>
      <g id="Graphic_86">
        <rect x="502" y="466.6442" width="19" height="25" fill="#c0c0ff"/>
        <rect x="502" y="466.6442" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(507 469.9202)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">6</tspan>
        </text>
      </g>
      <g id="Graphic_85">
        <rect x="521" y="466.6442" width="19" height="25" fill="#c0c0ff"/>
        <rect x="521" y="466.6442" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(526 469.9202)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">7</tspan>
        </text>
      </g>
      <g id="Graphic_97">
        <rect x="540" y="466.6442" width="19" height="25" fill="#c0c0ff"/>
        <rect x="540" y="466.6442" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(545 469.9202)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">0</tspan>
        </text>
      </g>
      <g id="Graphic_96">
        <rect x="559" y="466.6442" width="19" height="25" fill="#c0c0ff"/>
        <rect x="559" y="466.6442" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(564 469.9202)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">1</tspan>
        </text>
      </g>
      <g id="Graphic_95">
        <rect x="578" y="466.6442" width="19" height="25" fill="#c0c0ff"/>
        <rect x="578" y="466.6442" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(583 469.9202)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">2</tspan>
        </text>
      </g>
      <g id="Graphic_94">
        <rect x="597" y="466.6442" width="19" height="25" fill="#c0c0ff"/>
        <rect x="597" y="466.6442" width="19" height="25" stroke="gray" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
        <text transform="translate(602 469.9202)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x=".052" y="15" xml:space="preserve">3</tspan>
        </text>
      </g>
      <g id="Graphic_105">
        <rect x="236" y="466.6442" width="152" height="25" stroke="#b1001c" stroke-linecap="round" stroke-linejoin="round" stroke-width="3"/>
      </g>
      <g id="Graphic_106">
        <rect x="388" y="466.6442" width="152" height="25" stroke="#b1001c" stroke-linecap="round" stroke-linejoin="round" stroke-width="3"/>
      </g>
      <g id="Graphic_113">
        <rect x="540" y="466.6442" width="152" height="25" stroke="#b1001c" stroke-linecap="round" stroke-linejoin="round" stroke-width="3"/>
      </g>
      <g id="Line_126">
        <path d="M 236 442 L 236 442 C 236 450.29954 242.7281 457.02765 251.02765 457.02765 L 297.5128 457.02765 C 302.45403 457.02765 306.91434 459.9881 308.83333 464.5415 L 308.83333 464.5415 C 309.5704 466.2904 311.58567 467.11064 313.33458 466.37357 C 314.16093 466.0253 314.8184 465.36783 315.16667 464.5415 L 315.16667 464.5415 C 317.08566 459.9881 321.54597 457.02765 326.4872 457.02765 L 372.97235 457.02765 C 381.2719 457.02765 388 450.29954 388 442 L 388 442" stroke="#a5a5a5" stroke-linecap="round" stroke-linejoin="round" stroke-width="3"/>
      </g>
      <g id="Line_127">
        <path d="M 389 442 L 389 442 C 389 450.29954 395.7281 457.02765 404.02765 457.02765 L 450.5128 457.02765 C 455.45403 457.02765 459.91434 459.9881 461.83333 464.5415 L 461.83333 464.5415 C 462.5704 466.2904 464.5857 467.11064 466.3346 466.37357 C 467.1609 466.0253 467.8184 465.36783 468.16667 464.5415 L 468.16667 464.5415 C 470.08566 459.9881 474.54597 457.02765 479.4872 457.02765 L 525.97235 457.02765 C 534.2719 457.02765 541 450.29954 541 442 L 541 442" stroke="#a5a5a5" stroke-linecap="round" stroke-linejoin="round" stroke-width="3"/>
      </g>
      <g id="Line_128">
        <path d="M 542 442.03426 L 542 442.03426 C 542 450.3338 548.7281 457.0619 557.02765 457.0619 L 568.2463 457.0619 C 572.7114 457.0619 576.5609 460.20176 577.4583 464.57574 L 577.4583 464.57574 C 577.633 465.4272 578.4649 465.9758 579.3163 465.8011 C 579.9331 465.67454 580.4151 465.19254 580.5417 464.57574 L 580.5417 464.57574 C 581.4391 460.20176 585.2886 457.0619 589.7537 457.0619 L 600.97235 457.0619 C 609.2719 457.0619 616 450.3338 616 442.03426 L 616 442.03426" stroke="#a5a5a5" stroke-linecap="round" stroke-linejoin="round" stroke-width="3"/>
      </g>
      <g id="Graphic_130">
        <title>span[0]</title>
        <text transform="translate(286.1421 496.6442)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x="7887024e-19" y="15" xml:space="preserve">slice[0]</tspan>
        </text>
      </g>
      <g id="Graphic_131">
        <title>span[1]</title>
        <text transform="translate(440.264 496.6442)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x="7887024e-19" y="15" xml:space="preserve">slice[1]</tspan>
        </text>
      </g>
      <g id="Graphic_132">
        <text transform="translate(591.264 496.6442)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x="7887024e-19" y="15" xml:space="preserve">slice[2]</tspan>
        </text>
      </g>
      <g id="Graphic_139">
        <rect x="47.5" y="417" width="152" height="25" stroke="#14495e" stroke-linecap="round" stroke-linejoin="round" stroke-width="3"/>
      </g>
      <g id="Graphic_140">
        <rect x="199.5" y="417" width="152" height="25" stroke="#14495e" stroke-linecap="round" stroke-linejoin="round" stroke-width="3"/>
      </g>
      <g id="Graphic_141">
        <rect x="351.5" y="417" width="152" height="25" stroke="#14495e" stroke-linecap="round" stroke-linejoin="round" stroke-width="3"/>
      </g>
      <g id="Graphic_142">
        <rect x="503.5" y="417" width="152" height="25" stroke="#14495e" stroke-linecap="round" stroke-linejoin="round" stroke-width="3"/>
      </g>
      <g id="Graphic_143">
        <rect x="655.5" y="417" width="152" height="25" stroke="#14495e" stroke-linecap="round" stroke-linejoin="round" stroke-width="3"/>
      </g>
      <g id="Graphic_144">
        <text transform="translate(116.844 393.552)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x="8597567e-19" y="15" xml:space="preserve">w[0]</tspan>
        </text>
      </g>
      <g id="Graphic_145">
        <text transform="translate(266.528 393.552)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x="8597567e-19" y="15" xml:space="preserve">w[1]</tspan>
        </text>
      </g>
      <g id="Graphic_146">
        <text transform="translate(415.528 393.552)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x="8597567e-19" y="15" xml:space="preserve">w[2]</tspan>
        </text>
      </g>
      <g id="Graphic_147">
        <text transform="translate(564.528 393.552)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x="8597567e-19" y="15" xml:space="preserve">w[3]</tspan>
        </text>
      </g>
      <g id="Graphic_148">
        <text transform="translate(713.528 393.552)" fill="black">
          <tspan font-family="Helvetica Neue" font-size="16" fill="black" x="8597567e-19" y="15" xml:space="preserve">w[4]</tspan>
        </text>
      </g>
    </g>
  </g>
</svg>
