### Initialize Deflate64Decoder from Read

Source: https://context7.com/anatawa12/deflate64-rs/llms.txt

Demonstrates creating a decoder from a generic Read implementation and reading data either fully or in chunks.

```rust
use deflate64::Deflate64Decoder;
use std::io::{Cursor, Read};

fn decompress_from_reader(compressed: &[u8]) -> Vec<u8> {
    // Create decoder from any Read implementation
    let reader = Cursor::new(compressed);
    let mut decoder = Deflate64Decoder::new(reader);

    // Read all decompressed data
    let mut decompressed = Vec::new();
    decoder.read_to_end(&mut decompressed)
        .expect("Decompression failed");

    decompressed
}

// Example: Reading in chunks
fn decompress_chunked_reader(compressed: &[u8]) -> Vec<u8> {
    let mut decoder = Deflate64Decoder::new(Cursor::new(compressed));
    let mut result = Vec::new();
    let mut buffer = [0u8; 4096];

    loop {
        match decoder.read(&mut buffer) {
            Ok(0) => break,  // EOF
            Ok(n) => result.extend_from_slice(&buffer[..n]),
            Err(e) => panic!("Read error: {}", e),
        }
    }

    result
}
```

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

### Initialize Deflate64Decoder from BufRead

Source: https://context7.com/anatawa12/deflate64-rs/llms.txt

Uses with_buffer to initialize the decoder from a BufRead implementation, avoiding redundant buffering layers.

```rust
use deflate64::Deflate64Decoder;
use std::io::{BufReader, Cursor, Read};
use std::fs::File;

fn decompress_from_buffered_file(path: &str) -> std::io::Result<Vec<u8>> {
    let file = File::open(path)?;
    let buf_reader = BufReader::new(file);

    // Use with_buffer to avoid double buffering
    let mut decoder = Deflate64Decoder::with_buffer(buf_reader);

    let mut decompressed = Vec::new();
    decoder.read_to_end(&mut decompressed)?;

    Ok(decompressed)
}

fn decompress_from_cursor(compressed: &[u8]) -> Vec<u8> {
    // Cursor<&[u8]> implements BufRead
    let cursor = Cursor::new(compressed);
    let mut decoder = Deflate64Decoder::with_buffer(cursor);

    let mut decompressed = Vec::new();
    decoder.read_to_end(&mut decompressed).unwrap();

    decompressed
}
```

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

### Implement Checkpoint Saving

Source: https://context7.com/anatawa12/deflate64-rs/llms.txt

Requires the 'checkpoint' feature enabled. Use this to periodically save the inflater state to disk for resuming large decompression tasks.

```rust
#[cfg(feature = "checkpoint")]
use deflate64::{InflaterManaged, checkpoint::CheckpointStreamPositions};
use std::fs;

#[cfg(feature = "checkpoint")]
fn decompress_with_checkpoints(compressed: &[u8], checkpoint_interval: u64) -> Vec<u8> {
    let mut inflater = Box::new(InflaterManaged::new());
    let mut output = Vec::new();
    let mut buffer = vec![0u8; 64 * 1024];
    let mut total_written = 0u64;
    let mut last_checkpoint_at = 0u64;
    let mut consumed = 0;

    while !inflater.finished() {
        let result = inflater.inflate(&compressed[consumed..], &mut buffer);
        consumed += result.bytes_consumed;
        output.extend_from_slice(&buffer[..result.bytes_written]);
        total_written += result.bytes_written as u64;

        // Save checkpoint periodically
        if total_written - last_checkpoint_at >= checkpoint_interval {
            if let Some((checkpoint_data, positions)) = inflater.checkpoint() {
                // Save checkpoint to disk
                fs::write("decompress.checkpoint", &checkpoint_data)
                    .expect("Failed to save checkpoint");

                println!(
                    "Checkpoint saved: input={}, output={}",
                    positions.input_bytes_to_skip,
                    positions.output_bytes_already_returned
                );

                last_checkpoint_at = total_written;
            }
        }
    }

    // Clean up checkpoint file on success
    let _ = fs::remove_file("decompress.checkpoint");
    output
}
```

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

### Initialize InflaterManaged with Expected Size

Source: https://context7.com/anatawa12/deflate64-rs/llms.txt

Uses with_uncompressed_size to initialize the inflater when the final output size is known, allowing for automatic termination.

```rust
use deflate64::InflaterManaged;

fn decompress_with_known_size(compressed: &[u8], expected_size: usize) -> Vec<u8> {
    let mut output = vec![0u8; expected_size + 100]; // Small buffer margin

    // Create inflater with expected uncompressed size
    let mut inflater = Box::new(InflaterManaged::with_uncompressed_size(expected_size));

    let result = inflater.inflate(compressed, &mut output);

    assert!(!result.data_error, "Decompression error");
    assert_eq!(result.bytes_written, expected_size);

    output.truncate(result.bytes_written);
    output
}
```

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

### Implement Safe Error Handling

Source: https://context7.com/anatawa12/deflate64-rs/llms.txt

Demonstrates robust error handling for both low-level managed inflation and high-level streaming decoders. Includes checks for data corruption and stalled decompression.

```rust
use deflate64::{Deflate64Decoder, InflaterManaged};
use std::io::{self, Cursor, Read};

fn safe_decompress_low_level(compressed: &[u8]) -> Result<Vec<u8>, &'static str> {
    let mut inflater = Box::new(InflaterManaged::new());
    let mut output = Vec::new();
    let mut buffer = vec![0u8; 64 * 1024];
    let mut consumed = 0;

    while !inflater.finished() {
        let result = inflater.inflate(&compressed[consumed..], &mut buffer);

        if result.data_error {
            return Err("Invalid deflate64 data");
        }

        consumed += result.bytes_consumed;
        output.extend_from_slice(&buffer[..result.bytes_written]);

        // Prevent infinite loop on malformed data
        if result.bytes_consumed == 0 && result.bytes_written == 0 && !inflater.finished() {
            return Err("Decompression stalled - possibly truncated data");
        }
    }

    Ok(output)
}

fn safe_decompress_streaming(compressed: &[u8]) -> io::Result<Vec<u8>> {
    let mut decoder = Deflate64Decoder::new(Cursor::new(compressed));
    let mut output = Vec::new();

    // read_to_end returns io::Error with InvalidInput kind on deflate64 errors
    decoder.read_to_end(&mut output)?;

    Ok(output)
}
```

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

### Initialize InflaterManaged

Source: https://context7.com/anatawa12/deflate64-rs/llms.txt

Creates a new InflaterManaged instance to decompress raw Deflate64 data into a provided buffer.

```rust
use deflate64::InflaterManaged;

fn main() {
    // Compressed deflate64 data (raw deflate64 stream, not ZIP container)
    let compressed_data: &[u8] = &[/* compressed bytes */];

    // Create output buffer (must be large enough for decompressed data)
    let mut output = vec![0u8; 1024 * 1024]; // 1MB buffer

    // Create inflater and decompress
    let mut inflater = Box::new(InflaterManaged::new());
    let result = inflater.inflate(compressed_data, &mut output);

    // Check results
    println!("Bytes consumed from input: {}", result.bytes_consumed);
    println!("Bytes written to output: {}", result.bytes_written);
    println!("Data error occurred: {}", result.data_error);
    println!("Decompression finished: {}", inflater.finished());

    // Access decompressed data
    let decompressed = &output[..result.bytes_written];
}
```

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

### Deflate64Decoder::with_buffer

Source: https://context7.com/anatawa12/deflate64-rs/llms.txt

Creates a decoder from an existing `BufRead` implementation. This is more efficient when you already have a buffered reader, as it avoids adding an additional buffering layer.

```APIDOC
## Deflate64Decoder::with_buffer

### Description
Creates a decoder from an existing `BufRead` implementation. This is more efficient when you already have a buffered reader, as it avoids adding an additional buffering layer.

### Request Example
```rust
use deflate64::Deflate64Decoder;
use std::io::{BufReader, Cursor, Read};
use std::fs::File;

fn decompress_from_buffered_file(path: &str) -> std::io::Result<Vec<u8>> {
    let file = File::open(path)?;
    let buf_reader = BufReader::new(file);

    // Use with_buffer to avoid double buffering
    let mut decoder = Deflate64Decoder::with_buffer(buf_reader);

    let mut decompressed = Vec::new();
    decoder.read_to_end(&mut decompressed)?;

    Ok(decompressed)
}

fn decompress_from_cursor(compressed: &[u8]) -> Vec<u8> {
    // Cursor<&[u8]> implements BufRead
    let cursor = Cursor::new(compressed);
    let mut decoder = Deflate64Decoder::with_buffer(cursor);

    let mut decompressed = Vec::new();
    decoder.read_to_end(&mut decompressed).unwrap();

    decompressed
}
```
```

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

### Resume Decompression from Checkpoint

Source: https://context7.com/anatawa12/deflate64-rs/llms.txt

Restores a saved checkpoint to resume decompression. Requires the 'checkpoint' feature enabled and manual seeking of input/output streams to the positions returned by the checkpoint.

```rust
#[cfg(feature = "checkpoint")]
use deflate64::{InflaterManaged, checkpoint::CheckpointStreamPositions};
use std::io::{Seek, SeekFrom};
use std::fs::File;

#[cfg(feature = "checkpoint")]
fn resume_from_checkpoint(
    checkpoint_data: &[u8],
    compressed: &[u8],
) -> Option<Vec<u8>> {
    let mut inflater = Box::new(InflaterManaged::new());

    // Restore checkpoint - returns positions to seek to
    let positions: CheckpointStreamPositions = inflater.restore_from_checkpoint(checkpoint_data)?;

    println!(
        "Restored checkpoint: skip {} input bytes, {} output bytes already returned",
        positions.input_bytes_to_skip,
        positions.output_bytes_already_returned
    );

    // Skip already-processed input
    let input_start = positions.input_bytes_to_skip as usize;
    let remaining_input = &compressed[input_start..];

    // Continue decompression
    let mut output = Vec::new();
    let mut buffer = vec![0u8; 64 * 1024];
    let mut consumed = 0;

    while !inflater.finished() {
        let result = inflater.inflate(&remaining_input[consumed..], &mut buffer);
        consumed += result.bytes_consumed;
        output.extend_from_slice(&buffer[..result.bytes_written]);

        if result.data_error {
            return None;
        }
    }

    Some(output)
}

#[cfg(feature = "checkpoint")]
fn full_resume_workflow() {
    // Check for existing checkpoint
    if let Ok(checkpoint_data) = std::fs::read("decompress.checkpoint") {
        let compressed = std::fs::read("large_file.deflate64").unwrap();

        if let Some(remaining_output) = resume_from_checkpoint(&checkpoint_data, &compressed) {
            // Append remaining output to existing output file
            // (seek to positions.output_bytes_already_returned first)
            println!("Resumed and completed: {} additional bytes", remaining_output.len());
        }
    }
}
```

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

### InflaterManaged::new

Source: https://context7.com/anatawa12/deflate64-rs/llms.txt

Creates a new Deflate64 inflater instance for decompressing data. This is the core low-level API that provides direct control over the decompression process, allowing you to decompress data in chunks with full access to consumption and output statistics.

```APIDOC
## InflaterManaged::new

### Description
Creates a new Deflate64 inflater instance for decompressing data. This is the core low-level API that provides direct control over the decompression process, allowing you to decompress data in chunks with full access to consumption and output statistics.

### Method
`InflaterManaged::new()`

### Parameters
None

### Request Example
```rust
use deflate64::InflaterManaged;

fn main() {
    // Compressed deflate64 data (raw deflate64 stream, not ZIP container)
    let compressed_data: &[u8] = &[]; // Replace with actual compressed bytes

    // Create output buffer (must be large enough for decompressed data)
    let mut output = vec![0u8; 1024 * 1024]; // 1MB buffer

    // Create inflater and decompress
    let mut inflater = Box::new(InflaterManaged::new());
    let result = inflater.inflate(compressed_data, &mut output);

    // Check results
    println!("Bytes consumed from input: {}", result.bytes_consumed);
    println!("Bytes written to output: {}", result.bytes_written);
    println!("Data error occurred: {}", result.data_error);
    println!("Decompression finished: {}", inflater.finished());

    // Access decompressed data
    let decompressed = &output[..result.bytes_written];
}
```

### Response
#### Success Response
The `inflate` method returns an `InflateResult` struct containing:
- `bytes_consumed` (usize): The number of bytes consumed from the input buffer.
- `bytes_written` (usize): The number of bytes written to the output buffer.
- `data_error` (bool): True if a data error occurred during decompression.

The `InflaterManaged` instance also has a `finished()` method (bool) which returns true if decompression is complete.

#### Response Example
```json
{
  "bytes_consumed": 100,
  "bytes_written": 500,
  "data_error": false,
  "finished": true
}
```
```

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

### Deflate64Decoder::new

Source: https://context7.com/anatawa12/deflate64-rs/llms.txt

Creates a streaming decoder that wraps any `Read` implementation. This API implements the `Read` trait for easy integration with Rust's standard I/O.

```APIDOC
## Deflate64Decoder::new

### Description
Creates a streaming decoder that wraps any `Read` implementation. This high-level API implements the `Read` trait, making it easy to integrate with Rust's standard I/O ecosystem for decompressing data from files, network streams, or any other reader.

### Request Example
```rust
use deflate64::Deflate64Decoder;
use std::io::{Cursor, Read};

fn decompress_from_reader(compressed: &[u8]) -> Vec<u8> {
    // Create decoder from any Read implementation
    let reader = Cursor::new(compressed);
    let mut decoder = Deflate64Decoder::new(reader);

    // Read all decompressed data
    let mut decompressed = Vec::new();
    decoder.read_to_end(&mut decompressed)
        .expect("Decompression failed");

    decompressed
}

// Example: Reading in chunks
fn decompress_chunked_reader(compressed: &[u8]) -> Vec<u8> {
    let mut decoder = Deflate64Decoder::new(Cursor::new(compressed));
    let mut result = Vec::new();
    let mut buffer = [0u8; 4096];

    loop {
        match decoder.read(&mut buffer) {
            Ok(0) => break,  // EOF
            Ok(n) => result.extend_from_slice(&buffer[..n]),
            Err(e) => panic!("Read error: {}", e),
        }
    }

    result
}
```
```

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

### Query InflaterManaged State

Source: https://context7.com/anatawa12/deflate64-rs/llms.txt

Use these methods to monitor decompression progress, detect errors, and determine when input or output processing is complete.

```rust
use deflate64::InflaterManaged;

fn check_inflater_state(compressed: &[u8]) {
    let mut inflater = Box::new(InflaterManaged::new());
    let mut output = vec![0u8; 1024];

    loop {
        let result = inflater.inflate(compressed, &mut output);

        // Check if inflater encountered an error
        if inflater.errored() {
            eprintln!("Decompression error!");
            break;
        }

        // Check if all input has been processed (but output may still be buffered)
        if inflater.input_finished() {
            println!("Input processing complete");
        }

        // Check available buffered output
        let buffered = inflater.available_output();
        println!("Buffered output bytes: {}", buffered);

        // Check if completely finished (no more output available)
        if inflater.finished() {
            println!("Decompression complete!");
            break;
        }
    }
}
```

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

### InflaterManaged::with_uncompressed_size

Source: https://context7.com/anatawa12/deflate64-rs/llms.txt

Creates an inflater with a known expected uncompressed size. This is useful when you know the final decompressed size in advance (e.g., from ZIP file headers) and want the inflater to stop automatically when that size is reached.

```APIDOC
## InflaterManaged::with_uncompressed_size

### Description
Creates an inflater with a known expected uncompressed size. This is useful when you know the final decompressed size in advance (e.g., from ZIP file headers) and want the inflater to stop automatically when that size is reached.

### Method
`InflaterManaged::with_uncompressed_size(expected_size: usize)`

### Parameters
- **expected_size** (usize) - Required - The expected size of the uncompressed data.

### Request Example
```rust
use deflate64::InflaterManaged;

fn decompress_with_known_size(compressed: &[u8], expected_size: usize) -> Vec<u8> {
    let mut output = vec![0u8; expected_size + 100]; // Small buffer margin

    // Create inflater with expected uncompressed size
    let mut inflater = Box::new(InflaterManaged::with_uncompressed_size(expected_size));

    let result = inflater.inflate(compressed, &mut output);

    assert!(!result.data_error, "Decompression error");
    assert_eq!(result.bytes_written, expected_size);

    output.truncate(result.bytes_written);
    output
}
```

### Response
#### Success Response
The `inflate` method returns an `InflateResult` struct containing:
- `bytes_consumed` (usize): The number of bytes consumed from the input buffer.
- `bytes_written` (usize): The number of bytes written to the output buffer.
- `data_error` (bool): True if a data error occurred during decompression.

The inflater will automatically stop processing once `expected_size` bytes have been decompressed.

#### Response Example
```json
{
  "bytes_consumed": 150,
  "bytes_written": 1000,
  "data_error": false
}
```
```

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

### Deflate64Decoder Inner Access Methods

Source: https://context7.com/anatawa12/deflate64-rs/llms.txt

Methods to access the underlying reader for inspection or manipulation. These are useful when you need to check the state of the input stream or perform operations on the inner reader after decompression.

```APIDOC
## Deflate64Decoder Inner Access Methods

### Description
Methods to access the underlying reader for inspection or manipulation. These are useful when you need to check the state of the input stream or perform operations on the inner reader after decompression.

### Request Example
```rust
use deflate64::Deflate64Decoder;
use std::io::{Cursor, Read};

fn decoder_inner_access() {
    let data = vec![0u8; 100];
    let cursor = Cursor::new(data);
    let mut decoder = Deflate64Decoder::with_buffer(cursor);

    // Get immutable reference to inner reader
    let inner_ref = decoder.get_ref();
    println!("Cursor position: {}", inner_ref.position());

    // Get mutable reference to inner reader
    let inner_mut = decoder.get_mut();
    inner_mut.set_position(0);

    // Consume decoder and get inner reader back
    let inner = decoder.into_inner();
    println!("Final position: {}", inner.position());
}
```
```

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

### Perform Chunked Decompression

Source: https://context7.com/anatawa12/deflate64-rs/llms.txt

Processes input data in segments using a loop, suitable for streaming or large files. The process continues until the inflater is finished and all output is drained.

```rust
use deflate64::InflaterManaged;
use std::cmp::min;

fn decompress_chunked(compressed: &[u8], chunk_size: usize) -> Vec<u8> {
    let mut inflater = Box::new(InflaterManaged::new());
    let mut output = Vec::new();
    let mut output_buffer = vec![0u8; 64 * 1024]; // 64KB output chunks

    let mut input_offset = 0;

    while !inflater.finished() && input_offset < compressed.len() {
        // Process input in chunks
        let input_end = min(input_offset + chunk_size, compressed.len());
        let input_chunk = &compressed[input_offset..input_end];

        let result = inflater.inflate(input_chunk, &mut output_buffer);

        if result.data_error {
            panic!("Invalid deflate64 data");
        }

        // Advance input position by bytes actually consumed
        input_offset += result.bytes_consumed;

        // Collect output
        output.extend_from_slice(&output_buffer[..result.bytes_written]);
    }

    // Drain any remaining buffered output
    while inflater.available_output() > 0 {
        let result = inflater.inflate(&[], &mut output_buffer);
        output.extend_from_slice(&output_buffer[..result.bytes_written]);
    }

    output
}
```

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

### InflateResult Structure

Source: https://context7.com/anatawa12/deflate64-rs/llms.txt

The result structure returned by `inflate()` containing decompression statistics. It provides information about how many bytes were consumed from input, written to output, and whether any data errors occurred.

```APIDOC
## InflateResult Structure

### Description
The result structure returned by `inflate()` containing decompression statistics. It provides information about how many bytes were consumed from input, written to output, and whether any data errors occurred.

### Request Example
```rust
use deflate64::{InflaterManaged, InflateResult};

fn handle_inflate_result(compressed: &[u8]) {
    let mut inflater = Box::new(InflaterManaged::new());
    let mut output = vec![0u8; 1024];

    let result: InflateResult = inflater.inflate(compressed, &mut output);

    // bytes_consumed: Number of bytes read from input
    // (use this to advance your input position)
    let consumed = result.bytes_consumed;

    // bytes_written: Number of bytes written to output
    // (the actual decompressed data is output[..bytes_written])
    let written = result.bytes_written;

    // data_error: True if invalid deflate64 data was encountered
    if result.data_error {
        eprintln!("Error: Invalid deflate64 stream");
    }

    println!("Consumed {} bytes, wrote {} bytes", consumed, written);
}
```
```

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

### Handle InflateResult Statistics

Source: https://context7.com/anatawa12/deflate64-rs/llms.txt

Processes the result of an inflate operation to determine bytes consumed, bytes written, and error status.

```rust
use deflate64::{InflaterManaged, InflateResult};

fn handle_inflate_result(compressed: &[u8]) {
    let mut inflater = Box::new(InflaterManaged::new());
    let mut output = vec![0u8; 1024];

    let result: InflateResult = inflater.inflate(compressed, &mut output);

    // bytes_consumed: Number of bytes read from input
    // (use this to advance your input position)
    let consumed = result.bytes_consumed;

    // bytes_written: Number of bytes written to output
    // (the actual decompressed data is output[..bytes_written])
    let written = result.bytes_written;

    // data_error: True if invalid deflate64 data was encountered
    if result.data_error {
        eprintln!("Error: Invalid deflate64 stream");
    }

    println!("Consumed {} bytes, wrote {} bytes", consumed, written);
}
```

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

### InflaterManaged::inflate (Streaming/Chunked Decompression)

Source: https://context7.com/anatawa12/deflate64-rs/llms.txt

Performs streaming decompression by processing input data in chunks. This is essential for handling large files or network streams where data arrives incrementally. The method can be called repeatedly until `finished()` returns true.

```APIDOC
## InflaterManaged::inflate (Streaming/Chunked Decompression)

### Description
Performs streaming decompression by processing input data in chunks. This is essential for handling large files or network streams where data arrives incrementally. The method can be called repeatedly until `finished()` returns true.

### Method
`inflater.inflate(input_chunk: &[u8], output_buffer: &mut [u8]) -> InflateResult`

### Parameters
- **input_chunk** (`&[u8]`) - Required - A slice representing the current chunk of compressed data to process.
- **output_buffer** (`&mut [u8]`) - Required - A mutable slice where the decompressed data will be written.

### Request Example
```rust
use deflate64::InflaterManaged;
use std::cmp::min;

fn decompress_chunked(compressed: &[u8], chunk_size: usize) -> Vec<u8> {
    let mut inflater = Box::new(InflaterManaged::new());
    let mut output = Vec::new();
    let mut output_buffer = vec![0u8; 64 * 1024]; // 64KB output chunks

    let mut input_offset = 0;

    while !inflater.finished() && input_offset < compressed.len() {
        // Process input in chunks
        let input_end = min(input_offset + chunk_size, compressed.len());
        let input_chunk = &compressed[input_offset..input_end];

        let result = inflater.inflate(input_chunk, &mut output_buffer);

        if result.data_error {
            panic!("Invalid deflate64 data");
        }

        // Advance input position by bytes actually consumed
        input_offset += result.bytes_consumed;

        // Collect output
        output.extend_from_slice(&output_buffer[..result.bytes_written]);
    }

    // Drain any remaining buffered output
    while inflater.available_output() > 0 {
        let result = inflater.inflate(&[], &mut output_buffer);
        output.extend_from_slice(&output_buffer[..result.bytes_written]);
    }

    output
}
```

### Response
#### Success Response
The `inflate` method returns an `InflateResult` struct containing:
- `bytes_consumed` (usize): The number of bytes consumed from the `input_chunk`.
- `bytes_written` (usize): The number of bytes written to the `output_buffer`.
- `data_error` (bool): True if a data error occurred during decompression.

Call `inflater.finished()` to check if decompression is complete. Call `inflater.available_output()` to see if there's buffered data that needs to be drained.

#### Response Example
```json
{
  "bytes_consumed": 2048,
  "bytes_written": 4096,
  "data_error": false
}
```
```

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

### Access Inner Reader of Deflate64Decoder

Source: https://context7.com/anatawa12/deflate64-rs/llms.txt

Provides methods to retrieve immutable, mutable, or owned references to the underlying reader.

```rust
use deflate64::Deflate64Decoder;
use std::io::{Cursor, Read};

fn decoder_inner_access() {
    let data = vec![0u8; 100];
    let cursor = Cursor::new(data);
    let mut decoder = Deflate64Decoder::with_buffer(cursor);

    // Get immutable reference to inner reader
    let inner_ref = decoder.get_ref();
    println!("Cursor position: {}", inner_ref.position());

    // Get mutable reference to inner reader
    let inner_mut = decoder.get_mut();
    inner_mut.set_position(0);

    // Consume decoder and get inner reader back
    let inner = decoder.into_inner();
    println!("Final position: {}", inner.position());
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.