h3

https://docs.rs/h3/0.0.8/
Admin
h3 is a Rust crate that provides HTTP/3 client and server implementations over QUIC transport for...
Tokens:592,300
Snippets:3,827
Trust Score:9.7
Update:3 months ago
Show doc for...
Tokens:
Raw
### Simple HTTP/3 Server Example

Source: https://docs.rs/h3/0.0.8/h3/server/index.html

Demonstrates the basic setup for an HTTP/3 server. It shows how to build a connection, accept incoming requests, and send a simple response. This example requires a QUIC connection and is suitable for basic server implementations.

```rust
async fn doc<C>(conn: C)
where
C: h3::quic::Connection<bytes::Bytes> + 'static,
<C as h3::quic::OpenStreams<bytes::Bytes>>::BidiStream: Send + 'static
{
    let mut server_builder = h3::server::builder();
    // Build the Connection
    let mut h3_conn = server_builder.build(conn).await.unwrap();
    loop {
        // Accept incoming requests
        match h3_conn.accept().await {
            Ok(Some(resolver)) => {
                // spawn a new task to handle the request
                tokio::spawn(async move {
                    // get the request
                    let (req, mut stream) = resolver.resolve_request().await.unwrap();
                    // build a http response
                    let response = http::Response::builder().status(http::StatusCode::OK).body(()).unwrap();
                    // send the response to the wire
                    stream.send_response(response).await.unwrap();
                    // send some date
                    stream.send_data(bytes::Bytes::from("test")).await.unwrap();
                    // finnish the stream
                    stream.finish().await.unwrap();
                });
            }
            Ok(None) => {
                // break if no Request is accepted
                break;
            }
            Err(err) => {
                break;
            }
        }
    }
}
```

--------------------------------

### HTTP/3 Request and Response Handling Example

Source: https://docs.rs/h3/0.0.8/h3/client/struct.RequestStream.html?search=std%3A%3Avec

Demonstrates how to send an HTTP GET request and then receive and process the response, including its body, using RequestStream.

```rust
let request = Request::get("https://www.example.com/").body(())?;

let response = req_stream.recv_response().await?;
while let Some(mut chunk) = req_stream.recv_data().await? {
    let mut out = tokio::io::stdout();
    out.write_all_buf(&mut chunk).await?;
    out.flush().await?;
}
```

--------------------------------

### Example search queries

Source: https://docs.rs/h3/0.0.8/h3/client/fn.builder.html?search=

These are examples of search queries that can be performed. They demonstrate searching for types, type conversions, and generic type transformations.

```text
std::vec
```

```text
u32 -> bool
```

```text
Option<T>, (T -> U) -> Option<U>
```

--------------------------------

### Example: Handling HTTP/3 Request and Response Stream

Source: https://docs.rs/h3/0.0.8/src/h3/client/stream.rs.html?search=

Demonstrates how to send an HTTP GET request, receive the response headers, and then read the response body chunk by chunk. Ensure the response body is fully consumed before attempting to read trailers.

```rust
use bytes::Buf;
use http::{Request, Response};
use tokio::io::AsyncWriteExt;
use h3::{quic, client::*};

async fn doc<T,B>(mut req_stream: RequestStream<T, B>) -> Result<(), Box<dyn std::error::Error>>
where
    T: quic::RecvStream,
{
// Prepare the HTTP request to send to the server
let request = Request::get("https://www.example.com/").body(())?;

// Receive the response
let response = req_stream.recv_response().await?;
// Receive the body
while let Some(mut chunk) = req_stream.recv_data().await? {
    let mut out = tokio::io::stdout();
    out.write_all_buf(&mut chunk).await?;
    out.flush().await?;
}
Ok(())
}
pub fn main() {}
```

--------------------------------

### Example Searches in H3 Server

Source: https://docs.rs/h3/0.0.8/src/h3/server/request.rs.html?search=

Demonstrates various example search queries that can be performed. These examples cover searching for standard library items, type conversions, and functional transformations on optional types.

```rust
  * std::vec
```

```rust
  * u32 -> bool
```

```rust
  * Option<T>, (T -> U) -> Option<U>
```

--------------------------------

### QPACK Prefix String Decoding Examples (Part 4)

Source: https://docs.rs/h3/0.0.8/src/h3/qpack/prefix_string/decode.rs.html?search=std%3A%3Avec

Presents QPACK prefix string decoding examples that utilize 6-bit shifts for encoding, demonstrating how different combinations of prefix length and value are represented. These examples show the flexibility in QPACK encoding for various integer ranges.

```rust
192 => 0b1111_1111, 0b1111_1111, 0b1111_1000, (0b00 << 6) | /* padding */ 0b11_1111;
193 => 0b1111_1111, 0b1111_1111, 0b1111_1000, (0b01 << 6) | /* padding */ 0b11_1111;
200 => 0b1111_1111, 0b1111_1111, 0b1111_1000, (0b10 << 6) | /* padding */ 0b11_1111;
201 => 0b1111_1111, 0b1111_1111, 0b1111_1000, (0b11 << 6) | /* padding */ 0b11_1111;
202 => 0b1111_1111, 0b1111_1111, 0b1111_1001, (0b00 << 6) | /* padding */ 0b11_1111;
205 => 0b1111_1111, 0b1111_1111, 0b1111_1001, (0b01 << 6) | /* padding */ 0b11_1111;
210 => 0b1111_1111, 0b1111_1111, 0b1111_1001, (0b10 << 6) | /* padding */ 0b11_1111;
213 => 0b1111_1111, 0b1111_1111, 0b1111_1001, (0b11 << 6) | /* padding */ 0b11_1111;
218 => 0b1111_1111, 0b1111_1111, 0b1111_1010, (0b00 << 6) | /* padding */ 0b11_1111;
219 => 0b1111_1111, 0b1111_1111, 0b1111_1010, (0b01 << 6) | /* padding */ 0b11_1111;
238 => 0b1111_1111, 0b1111_1111, 0b1111_1010, (0b10 << 6) | /* padding */ 0b11_1111;
240 => 0b1111_1111, 0b1111_1111, 0b1111_1010, (0b11 << 6) | /* padding */ 0b11_1111;
242 => 0b1111_1111, 0b1111_1111, 0b1111_1011, (0b00 << 6) | /* padding */ 0b11_1111;
243 => 0b1111_1111, 0b1111_1111, 0b1111_1011, (0b01 << 6) | /* padding */ 0b11_1111;
255 => 0b1111_1111, 0b1111_1111, 0b1111_1011, (0b10 << 6) | /* padding */ 0b11_1111;
```

--------------------------------

### H3 QPACK Prefix String Encoding Example 1

Source: https://docs.rs/h3/0.0.8/src/h3/qpack/prefix_string/encode.rs.html

Illustrates the encoding of a prefix string using bitwise shifts and additions. This specific example constructs a byte sequence starting with 0b11111111.

```rust
1558                + 0b0000_1111,
1559            0b1111_1111,
1560            0b1111_1111,
1561            (0b0110_0000 << 1)
1562                // 212     |11111111|11111111|11111100|001
1563                + 0b0000_0001,
1564            0b1111_1111,
1565            0b1111_1111,
1566            0b1111_1000,
1567            (0b0000_0001 << 6)
1568                // 213     |11111111|11111111|11111001|11
1569                + 0b0011_1111,
1570            0b1111_1111,
1571            0b1111_1110,
1572            (0b0000_0111 << 4)
1573                // 214     |11111111|11111111|11111100|010
1574                + 0b0000_1111,
1575            0b1111_1111,
1576            0b1111_1111,
1577            (0b0110_0010 << 1)
1578                // 215     |11111111|11111111|11110010
1579                + 0b0000_0001,
1580            0b1111_1111,
1581            0b1111_1111,
1582            (0b0111_0010 << 1)
1583                // 216     |11111111|11111111|00100
1584                + 0b0000_0001,
1585            0b1111_1111,
1586            0b1111_1110,
1587            (0b0000_0100 << 4)
1588                // 217     |11111111|11111111|00101
1589                + 0b0000_1111,
1590            0b1111_1111,
1591            0b1111_0010,
1592            (0b0000_0001 << 7)
1593                // 218     |11111111|11111111|11111010|00
1594                + 0b0111_1111,
1595            0b1111_1111,
1596            0b1111_1101,
1597            (0b0000_0000 << 5)
1598                // 219     |11111111|11111111|11111010|01
1599                + 0b0001_1111,
1600            0b1111_1111,
1601            0b1111_1111,
1602            (0b0000_1001 << 3)
1603                // 220     |11111111|11111111|11111111|1101
1604                + 0b0000_0111,
1605            0b1111_1111,
1606            0b1111_1111,
1607            0b1111_1110,
1608            (0b0000_0001 << 7)
1609                // 221     |11111111|11111111|11111100|011
1610                + 0b0111_1111,
1611            0b1111_1111,
1612            0b1111_1110,
1613            (0b0000_0011 << 4)
1614                // 222     |11111111|11111111|11111100|100
1615                + 0b0000_1111,
1616            0b1111_1111,
1617            0b1111_1111,
1618            (0b0110_0100 << 1)
1619                // 223     |11111111|11111111|11111100|101
1620                + 0b0000_0001,
1621            0b1111_1111,
1622            0b1111_1111,
1623            0b1111_1001,
1624            (0b0000_0001 << 6)
1625                // 224     |11111111|11111110|1100
1626                + 0b0011_1111,
1627            0b1111_1111,
1628            (0b0010_1100 << 2)
1629                // 225     |11111111|11111111|11110011
1630                + 0b0000_0011,
1631            0b1111_1111,
1632            0b1111_1111,
1633            (0b0011_0011 << 2)
1634                // 226     |11111111|11111110|1101
1635                + 0b0000_0011,
1636            0b1111_1111,
1637            0b1111_1011,
1638            (0b0000_0001 << 6)
1639                // 227     |11111111|11111111|00110
1640                + 0b0011_1111,
1641            0b1111_1111,
1642            (0b0110_0110 << 1)
1643                // 228     |11111111|11111111|101001
1644                + 0b0000_0001,
1645            0b1111_1111,
1646            0b1111_1111,
1647            (0b0000_1001 << 3)
1648                // 229     |11111111|11111111|00111
1649                + 0b0000_0111,
1650            0b1111_1111,
1651            0b1111_1001,
1652            (0b0000_0011 << 6)
1653                // 230     |11111111|11111111|01000
1654                + 0b0011_1111,
1655            0b1111_1111,
1656            (0b0110_1000 << 1)
1657                // 231     |11111111|11111111|1110011
1658                + 0b0000_0001,
1659            0b1111_1111,
1660            0b1111_1111,
1661            (0b0011_0011 << 2)
1662                // 232     |11111111|11111111|101010
1663                + 0b0000_0011,
1664            0b1111_1111,
1665            0b1111_1110,
1666            (0b0000_1010 << 4)
1667                // 233     |11111111|11111111|101011
1668                + 0b0000_1111,
1669            0b1111_1111,
1670            0b1111_1010,
1671            (0b0000_0011 << 6)
1672                // 234     |11111111|11111111|11110111|0
1673                + 0b0011_1111,
1674            0b1111_1111,
1675            0b1111_1101,
1676            (0b0000_0110 << 5)
1677                // 235     |11111111|11111111|11110111|1
1678                + 0b0001_1111,
1679            0b1111_1111,
1680            0b1111_1110,
1681            (0b0000_1111 << 4)
1682                // 236     |11111111|11111111|11110100
1683                + 0b0000_1111,
1684            0b1111_1111,
1685            0b1111_1111,
1686            (0b0000_0100 << 4)
1687                // 237     |11111111|11111111|11110101
1688                + 0b0000_1111,
1689            0b1111_1111,
1690            0b1111_1111,
1691            (0b0000_0101 << 4)
```

--------------------------------

### QPACK Prefix String Decoding Examples

Source: https://docs.rs/h3/0.0.8/src/h3/qpack/prefix_string/decode.rs.html?search=u32+-%3E+bool

Illustrates various bitwise operations used in decoding QPACK prefix strings. These examples show how to construct integer values from bit patterns.

```rust
            0b111_1111,
            0b1111_1111,
            (0b110_0101 << 1)
                // 190     |11111111|11111111|100110
                + 0b1,
            0b1111_1111,
            0b1111_1111,
```

```rust
            0b1111_1111,
            0b1111_1111,
            (0b00110 << 3)
                // 191     |11111111|11111111|1110001
                + 0b111,
            0b1111_1111,
            0b1111_1111,
```

```rust
            0b1111_1111,
            0b1111_1111,
            (0b0001 << 4)
                // 192     |11111111|11111111|11111000|00
                + 0b1111,
            0b1111_1111,
            0b1111_1111,
```

```rust
            0b1111_1111,
            0b1111_1111,
            (0b10_0000 << 2)
                // 193     |11111111|11111111|11111000|01
                + 0b11,
            0b1111_1111,
            0b1111_1111,
```

```rust
            0b1111_1111,
            0b1111_1110,
            (0b1011 << 4)
                // 195     |11111111|11111110|001
                + 0b1111,
            0b1111_1111,
```

```rust
            0b1111_1111,
            0b1111_1111,
            (0b111_0001 << 1)
                // 196     |11111111|11111111|100111
                + 0b1,
            0b1111_1111,
            0b1111_1111,
```

```rust
            0b1111_1111,
            0b1111_1111,
            (0b00111 << 3)
                // 197     |11111111|11111111|1110010
                + 0b111,
            0b1111_1111,
            0b1111_1111,
```

```rust
            0b1111_1111,
            0b1111_1111,
            (0b0010 << 4)
                // 198     |11111111|11111111|101000
                + 0b1111,
            0b1111_1111,
            0b1111_1010,
```

```rust
            0b1111_1111,
            0b1111_1101,
            (0b100 << 5)
                // 200     |11111111|11111111|11111000|10
                + 0b11111,
            0b1111_1111,
            0b1111_1111,
```

```rust
            0b1111_1111,
            0b1111_1111,
            (0b00010 << 3)
                // 201     |11111111|11111111|11111000|11
                + 0b111,
            0b1111_1111,
            0b1111_1111,
```

```rust
            0b1111_1111,
            0b1111_1111,
            0b1111_0010,
            (0b0 << 7)
                // 203     |11111111|11111111|11111011|110
                + 0b111_1111,
            0b1111_1111,
            0b1111_1101,
```

```rust
            0b1111_1111,
            0b1111_1111,
            (0b101_1111 << 1)
                // 205     |11111111|11111111|11111001|01
                + 0b1,
            0b1111_1111,
            0b1111_1111,
            0b1111_0010,
```

```rust
            0b1111_1111,
            0b1111_1000,
            (0b1 << 7)
                // 207     |11111111|11111111|11110110|1
                + 0b111_1111,
            0b1111_1111,
            0b1111_1011,
```

```rust
            0b1111_1111,
            (0b10010 << 3)
                // 209     |11111111|11111111|00011
                + 0b111,
            0b1111_1111,
            0b1111_1000,
```

```rust
            0b1111_1111,
            0b1111_1110,
            (0b0110 << 4)
                // 211     |11111111|11111111|11111100|000
                + 0b1111,
            0b1111_1111,
            0b1111_1111,
```

```rust
            0b1111_1111,
            0b1111_1111,
            0b1111_1000,
            (0b01 << 6)
                // 213     |11111111|11111111|11111001|11
                + 0b11_1111,
            0b1111_1111,
            0b1111_1110,
```

```rust
            0b1111_1111,
            0b1111_1111,
            (0b110_0010 << 1)
                // 215     |11111111|11111111|11110010
                + 0b1,
            0b1111_1111,
            0b1111_1111,
```

```rust
            0b1111_1111,
            0b1111_1110,
            (0b0100 << 4)
                // 217     |11111111|11111111|00101
                + 0b1111,
```

--------------------------------

### QPACK Prefix String Decoding Examples

Source: https://docs.rs/h3/0.0.8/src/h3/qpack/prefix_string/decode.rs.html?search=u32+-%3E+bool

Illustrates various byte-to-bit pattern mappings used in QPACK prefix string decoding. These examples show how different byte values are translated into bit patterns for reconstruction.

```rust
94 => 0b1111_1111, (0b11_1100 << 2) | /* padding */ 0b11; // '^'
125 => 0b1111_1111, (0b11_1101 << 2) | /* padding */ 0b11; // '}'
60 => 0b1111_1111, (0b111_1100 << 1) | /* padding */ 0b1; // '<'
96 => 0b1111_1111, (0b111_1101 << 1) | /* padding */ 0b1; // '`'
123 => 0b1111_1111, (0b111_1110 << 1) | /* padding */ 0b1; // '{'
```

```rust
92 => 0b1111_1111, 0b1111_1110, (0b000 << 5) | /* padding */ 0b11111; // '\'
195 => 0b1111_1111, 0b1111_1110, (0b001 << 5) | /* padding */ 0b11111;
208 => 0b1111_1111, 0b1111_1110, (0b010 << 5) | /* padding */ 0b11111;
128 => 0b1111_1111, 0b1111_1110, (0b0110 << 4) | /* padding */ 0b1111;
130 => 0b1111_1111, 0b1111_1110, (0b0111 << 4) | /* padding */ 0b1111;
131 => 0b1111_1111, 0b1111_1110, (0b1000 << 4) | /* padding */ 0b1111;
162 => 0b1111_1111, 0b1111_1110, (0b1001 << 4) | /* padding */ 0b1111;
184 => 0b1111_1111, 0b1111_1110, (0b1010 << 4) | /* padding */ 0b1111;
194 => 0b1111_1111, 0b1111_1110, (0b1011 << 4) | /* padding */ 0b1111;
224 => 0b1111_1111, 0b1111_1110, (0b1100 << 4) | /* padding */ 0b1111;
226 => 0b1111_1111, 0b1111_1110, (0b1101 << 4) | /* padding */ 0b1111;
```

```rust
153 => 0b1111_1111, 0b1111_1110, (0b11100 << 3) | /* padding */ 0b111;
161 => 0b1111_1111, 0b1111_1110, (0b11101 << 3) | /* padding */ 0b111;
167 => 0b1111_1111, 0b1111_1110, (0b11110 << 3) | /* padding */ 0b111;
172 => 0b1111_1111, 0b1111_1110, (0b11111 << 3) | /* padding */ 0b111;
```

```rust
176 => 0b1111_1111, 0b1111_1111, (0b00000 << 3) | /* padding */ 0b111;
177 => 0b1111_1111, 0b1111_1111, (0b00001 << 3) | /* padding */ 0b111;
179 => 0b1111_1111, 0b1111_1111, (0b00010 << 3) | /* padding */ 0b111;
209 => 0b1111_1111, 0b1111_1111, (0b00011 << 3) | /* padding */ 0b111;
216 => 0b1111_1111, 0b1111_1111, (0b00100 << 3) | /* padding */ 0b111;
217 => 0b1111_1111, 0b1111_1111, (0b00101 << 3) | /* padding */ 0b111;
227 => 0b1111_1111, 0b1111_1111, (0b00110 << 3) | /* padding */ 0b111;
229 => 0b1111_1111, 0b1111_1111, (0b00111 << 3) | /* padding */ 0b111;
230 => 0b1111_1111, 0b1111_1111, (0b01000 << 3) | /* padding */ 0b111;
```

```rust
129 => 0b1111_1111, 0b1111_1111, (0b01_0010 << 2) | /* padding */ 0b11;
132 => 0b1111_1111, 0b1111_1111, (0b01_0011 << 2) | /* padding */ 0b11;
133 => 0b1111_1111, 0b1111_1111, (0b01_0100 << 2) | /* padding */ 0b11;
134 => 0b1111_1111, 0b1111_1111, (0b01_0101 << 2) | /* padding */ 0b11;
136 => 0b1111_1111, 0b1111_1111, (0b01_0110 << 2) | /* padding */ 0b11;
146 => 0b1111_1111, 0b1111_1111, (0b01_0111 << 2) | /* padding */ 0b11;
154 => 0b1111_1111, 0b1111_1111, (0b01_1000 << 2) | /* padding */ 0b11;
156 => 0b1111_1111, 0b1111_1111, (0b01_1001 << 2) | /* padding */ 0b11;
160 => 0b1111_1111, 0b1111_1111, (0b01_1010 << 2) | /* padding */ 0b11;
163 => 0b1111_1111, 0b1111_1111, (0b01_1011 << 2) | /* padding */ 0b11;
164 => 0b1111_1111, 0b1111_1111, (0b01_1100 << 2) | /* padding */ 0b11;
169 => 0b1111_1111, 0b1111_1111, (0b01_1101 << 2) | /* padding */ 0b11;
170 => 0b1111_1111, 0b1111_1111, (0b01_1110 << 2) | /* padding */ 0b11;
173 => 0b1111_1111, 0b1111_1111, (0b01_1111 << 2) | /* padding */ 0b11;
178 => 0b1111_1111, 0b1111_1111, (0b10_0000 << 2) | /* padding */ 0b11;
181 => 0b1111_1111, 0b1111_1111, (0b10_0001 << 2) | /* padding */ 0b11;
185 => 0b1111_1111, 0b1111_1111, (0b10_0010 << 2) | /* padding */ 0b11;
186 => 0b1111_1111, 0b1111_1111, (0b10_0011 << 2) | /* padding */ 0b11;
187 => 0b1111_1111, 0b1111_1111, (0b10_0100 << 2) | /* padding */ 0b11;
189 => 0b1111_1111, 0b1111_1111, (0b10_0101 << 2) | /* padding */ 0b11;
190 => 0b1111_1111, 0b1111_1111, (0b10_0110 << 2) | /* padding */ 0b11;
196 => 0b1111_1111, 0b1111_1111, (0b10_0111 << 2) | /* padding */ 0b11;
198 => 0b1111_1111, 0b1111_1111, (0b10_1000 << 2) | /* padding */ 0b11;
228 => 0b1111_1111, 0b1111_1111, (0b10_1001 << 2) | /* padding */ 0b11;
232 => 0b1111_1111, 0b1111_1111, (0b10_1010 << 2) | /* padding */ 0b11;
233 => 0b1111_1111, 0b1111_1111, (0b10_1011 << 2) | /* padding */ 0b11;
```

```rust
1 => 0b1111_1111, 0b1111_1111, (0b101_1000 << 1) | /* padding */ 0b1;
135 => 0b1111_1111, 0b1111_1111, (0b101_1001 << 1) | /* padding */ 0b1;
137 => 0b1111_1111, 0b1111_1111, (0b101_1010 << 1) | /* padding */ 0b1;
138 => 0b1111_1111, 0b1111_1111, (0b101_1011 << 1) | /* padding */ 0b1;
139 => 0b1111_1111, 0b1111_1111, (0b101_1100 << 1) | /* padding */ 0b1;
```

--------------------------------

### QPACK Prefix String Encoding Examples

Source: https://docs.rs/h3/0.0.8/src/h3/qpack/prefix_string/encode.rs.html?search=

Illustrates various bitwise operations for encoding prefix strings in QPACK. These examples show how different bit patterns are constructed using shifts and additions.

```rust
(0b0000_1111 << 4)
                // 184     |11111111|11111110|1010
                + 0b0000_1111,
            0b1111_1111,
            0b1110_1010,
```

```rust
0b1111_1111,
            0b1111_1111,
            (0b0010_0010 << 2)
                // 186     |11111111|11111111|100011
                + 0b0000_0011,
            0b1111_1111,
            0b1111_1110,
```

```rust
0b1111_1111,
            0b1111_1110,
            (0b0000_0011 << 4)
                // 187     |11111111|11111111|100100
                + 0b0000_1111,
            0b1111_1111,
            0b1111_1001,
```

```rust
0b1111_1111,
            0b1111_1001,
            (0b0000_0000 << 6)
                // 188     |11111111|11111111|1110000
                + 0b0011_1111,
            0b1111_1111,
            0b1111_1000,
```

```rust
0b1111_1111,
            0b1111_1000,
            (0b0000_0000 << 7)
                // 189     |11111111|11111111|100101
                + 0b0111_1111,
            0b1111_1111,
            (0b0110_0101 << 1)
```

```rust
(0b0110_0101 << 1)
                // 190     |11111111|11111111|100110
                + 0b0000_0001,
            0b1111_1111,
            0b1111_1111,
```

```rust
0b1111_1111,
            0b1111_1111,
            (0b0000_0110 << 3)
                // 191     |11111111|11111111|1110001
                + 0b0000_0111,
            0b1111_1111,
            0b1111_1111,
```

```rust
0b1111_1111,
            0b1111_1111,
            (0b0000_0001 << 4)
                // 192     |11111111|11111111|11111000|00
                + 0b0000_1111,
            0b1111_1111,
            0b1111_1111,
```

```rust
0b1111_1111,
            0b1111_1111,
            (0b0010_0000 << 2)
                // 193     |11111111|11111111|11111000|01
                + 0b0000_0011,
            0b1111_1111,
            0b1111_1111,
            0b1110_0001,
```

```rust
0b1111_1111,
            0b1111_1110,
            (0b0000_1011 << 4)
                // 195     |11111111|11111110|001
                + 0b0000_1111,
            0b1111_1111,
            (0b0111_0001 << 1)
```

```rust
(0b0111_0001 << 1)
                // 196     |11111111|11111111|100111
                + 0b0000_0001,
            0b1111_1111,
            0b1111_1111,
```

```rust
0b1111_1111,
            0b1111_1111,
            (0b0000_0110 << 3)
                // 197     |11111111|11111111|1110010
                + 0b0000_0111,
            0b1111_1111,
            0b1111_1111,
```

```rust
0b1111_1111,
            0b1111_1111,
            (0b0000_0010 << 4)
                // 198     |11111111|11111111|101000
                + 0b0000_1111,
            0b1111_1111,
            0b1111_1010,
```

```rust
0b1111_1111,
            0b1111_1010,
            (0b0000_0000 << 6)
                // 199     |11111111|11111111|11110110|0
                + 0b0011_1111,
            0b1111_1111,
            0b1111_1101,
```

```rust
0b1111_1111,
            0b1111_1101,
            (0b0000_0100 << 5)
                // 200     |11111111|11111111|11111000|10
                + 0b0001_1111,
            0b1111_1111,
            0b1111_1111,
```

```rust
0b1111_1111,
            0b1111_1111,
            (0b0000_0010 << 3)
                // 201     |11111111|11111111|11111000|11
                + 0b0000_0111,
            0b1111_1111,
            0b1111_1111,
```

```rust
0b1111_1111,
            0b1111_1111,
            (0b0110_0011 << 1)
                // 202     |11111111|11111111|11111001|00
                + 0b0000_0001,
            0b1111_1111,
            0b1111_1111,
            0b1111_0010,
```

```rust
0b1111_1111,
            0b1111_1111,
            0b1111_0010,
            (0b0000_0000 << 7)
                // 203     |11111111|11111111|11111011|110
                + 0b0111_1111,
            0b1111_1111,
            0b1111_1101,
```

```rust
0b1111_1111,
            0b1111_1101,
            (0b0000_1110 << 4)
                // 204     |11111111|11111111|11111011|111
                + 0b0000_1111,
            0b1111_1111,
            0b1111_1111,
```

```rust
0b1111_1111,
            0b1111_1111,
            (0b0101_1111 << 1)
                // 205     |11111111|11111111|11111001|01
                + 0b0000_0001,
            0b1111_1111,
            0b1111_1111,
            0b1111_0010,
```

```rust
0b1111_1111,
            0b1111_1111,
            0b1111_0010,
            (0b0000_0001 << 7)
                // 206     |11111111|11111111|11110001
                + 0b0111_1111,
            0b1111_1111,
            0b1111_1000,
```

```rust
0b1111_1111,
            0b1111_1000,
            (0b0000_0001 << 7)
                // 207     |11111111|11111111|11110110|1
                + 0b0111_1111,
            0b1111_1111,
            0b1111_1011,
```

```rust
0b1111_1111,
            0b1111_1011,
            (0b0000_0001 << 6)
                // 208     |11111111|11111110|010
                + 0b0011_1111,
            0b1111_1111,
            (0b0001_0010 << 3)
```

```rust
(0b0001_0010 << 3)
                // 209     |11111111|11111111|00011
                + 0b0000_0111,
            0b1111_1111,
            0b1111_1000,
```

```rust
0b1111_1111,
            0b1111_1000,
            (0b0000_0011 << 6)
                // 210     |11111111|11111111|11111001|10
                + 0b0011_1111,
            0b1111_1111,
            0b1111_1110,
```

```rust
0b1111_1111,
            0b1111_1110,
            (0b0000_0110 << 4)
                // 211     |11111111|11111111|11111100|000
```
Tokens:
Raw