diff --git a/Cargo.lock b/Cargo.lock
index 0f62b14d..016391da 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -338,6 +338,7 @@ dependencies = [
  "divan",
  "float_eq",
  "glam",
+ "nom",
  "num",
  "proptest",
  "rstest",
@@ -670,25 +671,25 @@ dependencies = [
 
 [[package]]
 name = "regex"
-version = "1.10.0"
+version = "1.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d119d7c7ca818f8a53c300863d4f87566aac09943aef5b355bb83969dae75d87"
+checksum = "aaac441002f822bc9705a681810a4dd2963094b9ca0ddc41cb963a4c189189ea"
 dependencies = [
  "aho-corasick",
  "memchr",
  "regex-automata",
- "regex-syntax 0.8.1",
+ "regex-syntax 0.8.2",
 ]
 
 [[package]]
 name = "regex-automata"
-version = "0.4.1"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "465c6fc0621e4abc4187a2bda0937bfd4f722c2730b29562e19689ea796c9a4b"
+checksum = "5011c7e263a695dc8ca064cddb722af1be54e517a280b12a5356f98366899e5d"
 dependencies = [
  "aho-corasick",
  "memchr",
- "regex-syntax 0.8.1",
+ "regex-syntax 0.8.2",
 ]
 
 [[package]]
@@ -705,9 +706,9 @@ checksum = "dbb5fb1acd8a1a18b3dd5be62d25485eb770e05afb408a9627d14d451bae12da"
 
 [[package]]
 name = "regex-syntax"
-version = "0.8.1"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56d84fdd47036b038fc80dd333d10b6aab10d5d31f4a366e20014def75328d33"
+checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f"
 
 [[package]]
 name = "relative-path"
@@ -755,9 +756,9 @@ dependencies = [
 
 [[package]]
 name = "rustix"
-version = "0.38.18"
+version = "0.38.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a74ee2d7c2581cd139b42447d7d9389b889bdaad3a73f1ebb16f2a3237bb19c"
+checksum = "745ecfa778e66b2b63c88a61cb36e0eea109e803b0b86bf9879fbc77c70e86ed"
 dependencies = [
  "bitflags 2.4.0",
  "errno",
diff --git a/crates/lox_core/Cargo.toml b/crates/lox_core/Cargo.toml
index b90e4a25..b80050b8 100644
--- a/crates/lox_core/Cargo.toml
+++ b/crates/lox_core/Cargo.toml
@@ -8,6 +8,7 @@ float_eq = "1.0.1"
 glam = "0.24.2"
 num = "0.4.0"
 thiserror.workspace = true
+nom = "7.1.3"
 
 [dev-dependencies]
 proptest = "1.1.0"
diff --git a/crates/lox_core/src/ephemeris.rs b/crates/lox_core/src/ephemeris.rs
new file mode 100644
index 00000000..801695c7
--- /dev/null
+++ b/crates/lox_core/src/ephemeris.rs
@@ -0,0 +1 @@
+pub mod daf_spk;
diff --git a/crates/lox_core/src/ephemeris/daf_spk.rs b/crates/lox_core/src/ephemeris/daf_spk.rs
new file mode 100644
index 00000000..070a9576
--- /dev/null
+++ b/crates/lox_core/src/ephemeris/daf_spk.rs
@@ -0,0 +1,2 @@
+pub mod api;
+pub mod parser;
diff --git a/crates/lox_core/src/ephemeris/daf_spk/api.rs b/crates/lox_core/src/ephemeris/daf_spk/api.rs
new file mode 100644
index 00000000..bdb93281
--- /dev/null
+++ b/crates/lox_core/src/ephemeris/daf_spk/api.rs
@@ -0,0 +1,268 @@
+use std::collections::HashMap;
+
+use super::parser::{DafSpkError, Spk, SpkSegment, SpkType2Array, SpkType2Coefficients};
+
+type Position = (f64, f64, f64);
+type Velocity = (f64, f64, f64);
+type Epoch = f64;
+type Body = i32;
+
+impl Spk {
+    fn find_segment(
+        &self,
+        origin: Body,
+        target: Body,
+    ) -> Result<(&SpkSegment, isize), DafSpkError> {
+        let mut sign = 1;
+
+        let mut target = target;
+        let mut origin = origin;
+        if target < origin {
+            (origin, target) = (target, origin);
+            sign = -1;
+        }
+
+        // An SPK file may contain any number of segments. A single file may contain overlapping segments:
+        // segments containing data for the same body over a common interval. When this happens, the
+        // latest segment in a file supersedes any competing segments earlier in the file.
+        let segment = self
+            .segments
+            .get(&origin)
+            .ok_or(DafSpkError::UnableToFindMatchingSegment)?
+            .get(&target)
+            .ok_or(DafSpkError::UnableToFindMatchingSegment)?
+            .last()
+            .ok_or(DafSpkError::UnableToFindMatchingSegment)?;
+
+        Ok((&segment, sign))
+    }
+
+    fn find_record<'a>(
+        &'a self,
+        array: &'a SpkType2Array,
+        initial_epoch: Epoch,
+        epoch: Epoch,
+    ) -> Result<(&Vec<SpkType2Coefficients>, f64), DafSpkError> {
+        let seconds_from_record_start = epoch - initial_epoch;
+
+        let intlen = array.intlen as f64;
+        let mut record_number = (seconds_from_record_start / intlen).floor() as usize;
+        let mut fraction = seconds_from_record_start % intlen;
+
+        // Chebyshev piecewise polynomials overlap at patchpoints. This means that one
+        // can safely take the end of the interval from the next record. But this implies
+        // special handling of the last record, where there's no next record that we can
+        // draw from.
+        if record_number == array.n as usize {
+            record_number -= 1;
+            fraction = array.intlen as f64;
+        }
+
+        let record = array
+            .records
+            .get(record_number)
+            .ok_or(DafSpkError::UnableToFindMatchingRecord)?;
+
+        Ok((record, fraction))
+    }
+
+    pub fn get_segments(&self) -> &HashMap<i32, HashMap<i32, Vec<SpkSegment>>> {
+        &self.segments
+    }
+
+    fn get_chebyshev_polynomial<'a>(
+        &'a self,
+        epoch: Epoch,
+        segment: &'a SpkSegment,
+    ) -> Result<(Vec<f64>, &Vec<SpkType2Coefficients>), DafSpkError> {
+        let (coefficients, record) = match &segment.data {
+            super::parser::SpkArray::Type2(array) => {
+                let (record, fraction) = self.find_record(array, segment.initial_epoch, epoch)?;
+
+                let degree_of_polynomial = array.degree_of_polynomial() as usize;
+                let mut coefficients = Vec::<f64>::with_capacity(degree_of_polynomial);
+
+                coefficients.push(1f64);
+                coefficients.push(2f64 * fraction / array.intlen as f64 - 1f64);
+
+                for i in 2..degree_of_polynomial {
+                    coefficients
+                        .push(2f64 * coefficients[1] * coefficients[i - 1] - coefficients[i - 2]);
+                }
+
+                (coefficients, record)
+            }
+        };
+
+        Ok((coefficients, record))
+    }
+
+    pub fn position(
+        &self,
+        epoch: Epoch,
+        origin: Body,
+        target: Body,
+    ) -> Result<Position, DafSpkError> {
+        let (segment, sign) = self.find_segment(origin, target)?;
+
+        if epoch < segment.initial_epoch || epoch > segment.final_epoch {
+            return Err(DafSpkError::UnableToFindMatchingSegment);
+        }
+
+        let mut x = 0f64;
+        let mut y = 0f64;
+        let mut z = 0f64;
+
+        match &segment.data {
+            super::parser::SpkArray::Type2(array) => {
+                let (polynomial, record) = self.get_chebyshev_polynomial(epoch, segment)?;
+                let sign = sign as f64;
+
+                let degree_of_polynomial = array.degree_of_polynomial() as usize;
+
+                #[allow(clippy::needless_range_loop)]
+                for i in 0..degree_of_polynomial {
+                    x += sign * record[i].x * polynomial[i];
+                    y += sign * record[i].y * polynomial[i];
+                    z += sign * record[i].z * polynomial[i];
+                }
+            }
+        }
+
+        Ok((x, y, z))
+    }
+
+    pub fn velocity(
+        &self,
+        epoch: Epoch,
+        origin: Body,
+        target: Body,
+    ) -> Result<Velocity, DafSpkError> {
+        let (segment, sign) = self.find_segment(origin, target)?;
+
+        if epoch < segment.initial_epoch || epoch > segment.final_epoch {
+            return Err(DafSpkError::UnableToFindMatchingSegment);
+        }
+
+        let mut x = 0f64;
+        let mut y = 0f64;
+        let mut z = 0f64;
+
+        match &segment.data {
+            super::parser::SpkArray::Type2(array) => {
+                let (polynomial, record) = self.get_chebyshev_polynomial(epoch, segment)?;
+                let sign = sign as f64;
+
+                let degree_of_polynomial = array.degree_of_polynomial() as usize;
+
+                let mut derivative = Vec::<f64>::with_capacity(degree_of_polynomial);
+
+                derivative.push(0f64);
+                derivative.push(1f64);
+
+                if degree_of_polynomial > 2 {
+                    derivative.push(4f64 * polynomial[1]);
+                    for i in 3..degree_of_polynomial {
+                        let x = 2f64 * polynomial[1] * derivative[i - 1] - derivative[i - 2]
+                            + polynomial[i - 1]
+                            + polynomial[i - 1];
+
+                        derivative.push(x);
+                    }
+                }
+
+                let derivative: Vec<f64> = derivative
+                    .iter()
+                    .map(|d| 2.0 * d / array.intlen as f64)
+                    .collect();
+
+                #[allow(clippy::needless_range_loop)]
+                for i in 0..degree_of_polynomial {
+                    x += sign * record[i].x * derivative[i];
+                    y += sign * record[i].y * derivative[i];
+                    z += sign * record[i].z * derivative[i];
+                }
+            }
+        }
+
+        Ok((x, y, z))
+    }
+
+    pub fn state(
+        &self,
+        epoch: Epoch,
+        origin: Body,
+        target: Body,
+    ) -> Result<(Position, Velocity), DafSpkError> {
+        let position = self.position(epoch, origin, target)?;
+        let velocity = self.velocity(epoch, origin, target)?;
+
+        Ok((position, velocity))
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::ephemeris::daf_spk::parser::parse_daf_spk;
+    use crate::ephemeris::daf_spk::parser::test::{get_expected_segments, FILE_CONTENTS};
+
+    use super::*;
+
+    #[test]
+    fn test_unable_to_find_segment() {
+        let spk = parse_daf_spk(&FILE_CONTENTS).expect("Unable to parse DAF/SPK");
+
+        assert_eq!(
+            Err(DafSpkError::UnableToFindMatchingSegment),
+            spk.position(2457388.5000000 as Epoch, 1, 2)
+        );
+    }
+
+    #[test]
+    fn test_position() {
+        let spk = parse_daf_spk(&FILE_CONTENTS).expect("Unable to parse DAF/SPK");
+
+        assert_eq!(
+            Ok((-32703259.291699532, 31370540.51993667, 20159681.594182793)),
+            spk.position(-14200747200.0 as Epoch, 0, 1)
+        );
+    }
+
+    #[test]
+    fn test_velocity() {
+        let spk = parse_daf_spk(&FILE_CONTENTS).expect("Unable to parse DAF/SPK");
+
+        assert_eq!(
+            Ok((
+                -46.723420416476635,
+                -28.050723083678367,
+                -10.055174230490163,
+            )),
+            spk.velocity(-14200747200.0 as Epoch, 0, 1)
+        );
+    }
+
+    #[test]
+    fn test_state() {
+        let spk = parse_daf_spk(&FILE_CONTENTS).expect("Unable to parse DAF/SPK");
+
+        assert_eq!(
+            Ok((
+                (-32703259.291699532, 31370540.51993667, 20159681.594182793),
+                (
+                    -46.723420416476635,
+                    -28.050723083678367,
+                    -10.055174230490163,
+                ),
+            )),
+            spk.state(-14200747200.0 as Epoch, 0, 1)
+        );
+    }
+
+    #[test]
+    fn test_get_segments() {
+        let spk = parse_daf_spk(&FILE_CONTENTS).expect("Unable to parse DAF/SPK");
+
+        assert_eq!(&get_expected_segments(), spk.get_segments());
+    }
+}
diff --git a/crates/lox_core/src/ephemeris/daf_spk/parser.rs b/crates/lox_core/src/ephemeris/daf_spk/parser.rs
new file mode 100644
index 00000000..93d65137
--- /dev/null
+++ b/crates/lox_core/src/ephemeris/daf_spk/parser.rs
@@ -0,0 +1,2752 @@
+use std::collections::HashMap;
+use std::iter::zip;
+
+use nom::error::ErrorKind;
+
+use nom::bytes::complete as nb;
+use nom::number::complete as nn;
+
+type BodyId = i32;
+
+const RECORD_SIZE: u32 = 1024;
+
+#[derive(Debug, PartialEq)]
+pub struct DafFileRecord {
+    pub locidw: String,
+    pub nd: u32,
+    pub ni: u32,
+    pub locifn: String,
+    pub fward: u32,
+    pub bward: u32,
+    pub free: u32,
+    pub locfmt: String,
+    pub prenul: Vec<u8>,
+    pub ftpstr: Vec<u8>,
+    pub pstnul: Vec<u8>,
+}
+
+#[derive(Debug, PartialEq)]
+pub struct DafComponents {
+    pub double_precision_components: Vec<f64>,
+    pub integer_components: Vec<i32>,
+}
+
+#[derive(Debug, PartialEq)]
+
+pub struct DafSummary {
+    pub name: String,
+    pub components: DafComponents,
+    pub initial_address: usize,
+    pub final_address: usize,
+}
+
+#[derive(Debug, PartialEq)]
+pub enum DafSpkError {
+    // The data type integer value does not match the ones in the spec
+    InvalidSpkSegmentDataType,
+    // The number of DAF components does not match the SPK specification
+    UnexpectedNumberOfComponents,
+    UnableToParse,
+    UnsupportedSpkArrayType { data_type: i32 },
+    // Unable to find the segment for a given center body and target body
+    UnableToFindMatchingSegment,
+    // Unable to find record for a given date
+    UnableToFindMatchingRecord,
+}
+
+#[derive(Debug, PartialEq)]
+pub struct SpkType2Coefficients {
+    pub x: f64,
+    pub y: f64,
+    pub z: f64,
+}
+
+#[derive(Debug, PartialEq)]
+pub struct SpkType2Array {
+    pub records: Vec<Vec<SpkType2Coefficients>>,
+    pub init: u32,
+    pub intlen: u32,
+    pub rsize: u32,
+    pub n: u32,
+}
+
+impl SpkType2Array {
+    pub fn degree_of_polynomial(&self) -> u32 {
+        degree_of_chebyshev_polynomial(self.rsize)
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub enum SpkArray {
+    Type2(SpkType2Array),
+}
+
+#[derive(Debug, PartialEq)]
+pub struct SpkSegment {
+    pub name: String,
+    // In J2000 epoch
+    pub initial_epoch: f64,
+    // In J2000 epoch
+    pub final_epoch: f64,
+    // NAIF id of the target
+    pub target_id: BodyId,
+    // NAIF id of the center
+    pub center_id: BodyId,
+    // NAIF id of the reference frame
+    pub reference_frame_id: BodyId,
+    pub data_type: i32,
+    pub initial_address: usize,
+    pub final_address: usize,
+    pub data: SpkArray,
+}
+
+#[derive(Debug, PartialEq)]
+pub struct DafSummaryRecord {
+    pub next: u32,
+    pub count: u32,
+    pub summaries: Vec<DafSummary>,
+}
+
+#[derive(Debug, PartialEq)]
+pub struct Spk {
+    pub file_record: DafFileRecord,
+    pub comment: String,
+    pub segments: HashMap<BodyId, HashMap<BodyId, Vec<SpkSegment>>>,
+}
+
+pub fn parse_daf_file_record_endianness(
+    input: &[u8],
+) -> nom::IResult<&[u8], nom::number::Endianness> {
+    // 8. LOCFMT ( 8 charactersu8, 8 bytes): The character string that indicates the
+    // numeric binary format of the DAF. The string has value either "LTL-IEEE"
+    // or "BIG-IEEE." [Address 88]
+    let (_, locfmt) = nom::branch::alt((nb::tag("LTL-IEEE"), nb::tag("BIG-IEEE")))(&input[88..])?;
+
+    // We know the loc strings are ASCII in the spec, so parsing them as utf-8
+    // should be safe.
+    let locfmt = String::from_utf8_lossy(locfmt).trim().to_string();
+
+    let endianness = match locfmt.as_str() {
+        "LTL-IEEE" => nom::number::Endianness::Little,
+        "BIG-IEEE" => nom::number::Endianness::Big,
+        _ => unreachable!(),
+    };
+
+    Ok((input, endianness))
+}
+
+pub fn parse_daf_file_record(
+    input: &[u8],
+) -> nom::IResult<&[u8], (nom::number::Endianness, DafFileRecord)> {
+    let (_, endianness) = parse_daf_file_record_endianness(input)?;
+
+    // 1. LOCIDW (8 charactersu8, 8 bytes): An identification word (`DAF/xxxx').
+    // The 'xxxx' substring is a string of four characters or less indicating the
+    // type of data stored in the DAF file. This is used by the SPICELIB
+    // subroutines to verify that a particular file is in fact a DAF and not
+    // merely a direct access file with the same record length. When
+    // a DAF is openedu8, an error signals if this keyword is not present. [Address
+    // 0]
+    let (input, locidw) = nb::take(8u32)(input)?;
+
+    // 2. ND ( 1 integeru8, 4 bytes): The number of double precision components in
+    // each array summary. [Address 8]
+    let (input, nd) = nn::u32(endianness)(input)?;
+
+    // 3. NI ( 1 integeru8, 4 bytes): The number of integer components in each array
+    // summary. [Address 12]
+    let (input, ni) = nn::u32(endianness)(input)?;
+
+    // 4. LOCIFN (60 charactersu8, 60 bytes): The internal name or description of
+    // the array file. [Address 16]
+    let (input, locifn) = nb::take(60u32)(input)?;
+
+    // 5. FWARD ( 1 integeru8, 4 bytes): The record number of the initial summary
+    // record in the file. [Address 76]
+    let (input, fward) = nn::u32(endianness)(input)?;
+
+    // 6. BWARD ( 1 integeru8, 4 bytes): The record number of the final summary
+    // record in the file. [Address 80]
+    let (input, bward) = nn::u32(endianness)(input)?;
+
+    // 7. FREE ( 1 integeru8, 4 bytes): The first free address in the file. This is
+    // the address at which the first element of the next array to be added to
+    // the file will be stored. [Address 84]
+    let (input, free) = nn::u32(endianness)(input)?;
+
+    // 8. LOCFMT ( 8 charactersu8, 8 bytes): The character string that indicates the
+    // numeric binary format of the DAF. The string has value either "LTL-IEEE"
+    // or "BIG-IEEE." [Address 88]
+    let (input, locfmt) = nb::take(8u32)(input)?;
+
+    // 9. PRENUL ( 603 charactersu8, 603 bytes): A block of nulls to pad between the
+    // last character of LOCFMT and the first character of FTPSTR to keep FTPSTR
+    // at character 700 (address 699) in a 1024 byte record. [Address 96]
+    let (input, prenul) = nb::take(603u32)(input)?;
+
+    // 10. FTPSTR ( 28 charactersu8, 28 bytes): The FTP validation string.
+    // This string is assembled using components returned from the SPICELIB private
+    // routine ZZFTPSTR. [Address 699]
+    let (input, ftpstr) = nb::take(28u32)(input)?;
+
+    // 11. PSTNUL ( 297 charactersu8, 297 bytes): A block of nulls to pad from the
+    // last character of FTPSTR to the end of the file record. Note: this value
+    // enforces the length of the file record as 1024 bytes. [Address 727]
+    let (input, pstnul) = nb::take(297u32)(input)?;
+
+    // We know the loc strings are ASCII in the spec, so parsing them as utf-8
+    // should be safe.
+    Ok((
+        input,
+        (
+            endianness,
+            DafFileRecord {
+                locidw: String::from_utf8_lossy(locidw).trim().to_string(),
+                nd,
+                ni,
+                locifn: String::from_utf8_lossy(locifn).trim().to_string(),
+                fward,
+                bward,
+                free,
+                locfmt: String::from_utf8_lossy(locfmt).trim().to_string(),
+                prenul: prenul.to_owned(),
+                ftpstr: ftpstr.to_owned(),
+                pstnul: pstnul.to_owned(),
+            },
+        ),
+    ))
+}
+
+pub fn parse_daf_comment_area(
+    input: &[u8],
+    comment_areas_count: u32,
+) -> nom::IResult<&[u8], String> {
+    let record_size = 1000;
+
+    let mut comment_area = String::with_capacity((comment_areas_count * record_size) as usize);
+
+    let mut input_cursor = input;
+    for _ in 0..comment_areas_count {
+        let comment_areas;
+        (input_cursor, comment_areas) = nb::take(RECORD_SIZE)(input_cursor)?;
+
+        let (_, comment_record_content) = nb::take(record_size)(comment_areas)?;
+
+        let comment_record_content = match nb::take_until("\x04")(comment_record_content) {
+            Ok((_, content_to_end_of_transmission_char)) => content_to_end_of_transmission_char,
+            Err(error) => match error {
+                // This is one ugly error type. What we're saying here is, if we can't
+                // find the end of transmission character, just return the whole thing.
+                nom::Err::Error(nom::error::Error {
+                    input: _,
+                    code: ErrorKind::TakeUntil,
+                }) => comment_record_content,
+                _ => Err(error)?,
+            },
+        };
+
+        let comment_record_content =
+            String::from_utf8_lossy(comment_record_content).replace('\0', "\n");
+
+        comment_area.push_str(&comment_record_content)
+    }
+
+    let comment_area = comment_area.trim().to_string();
+
+    Ok((input_cursor, comment_area))
+}
+
+pub fn parse_daf_summary_and_name_record_pair(
+    input: &[u8],
+    endianness: nom::number::Endianness,
+    nd: u32,
+    ni: u32,
+) -> nom::IResult<&[u8], DafSummaryRecord> {
+    let summary_record_input = input;
+    let mut name_record_input = &input[RECORD_SIZE as usize..];
+
+    let nc = 8 * (nd + (ni + 1) / 2);
+
+    // 1. The record number of the next summary record in the file. (Zero if this is
+    // the final summary record.)
+    let (summary_record_input, next) = nn::f64(endianness)(summary_record_input)?;
+    let next = next as u32;
+
+    // 2. The record number of the previous summary record in the file. (Zero if
+    // this is the initial summary record.)
+    let (summary_record_input, _) = nn::f64(endianness)(summary_record_input)?;
+
+    // 3. The number of summaries stored in this record.
+    let (mut summary_record_input, nsum) = nn::f64(endianness)(summary_record_input)?;
+    let nsum = nsum as u32;
+
+    let mut summaries = Vec::with_capacity(nsum as usize);
+
+    for _ in 0..nsum {
+        let double_precision_components;
+        (summary_record_input, double_precision_components) =
+            nom::multi::many_m_n(nd as usize, nd as usize, nn::f64(endianness))(
+                summary_record_input,
+            )?;
+
+        // The initial and final addresses of an array are always the values of the
+        // final two integer components of the summary for the array.
+        assert!(ni >= 2, "A correct DAF file has NI >= 2");
+        let component_count_without_addresses = ni - 2;
+
+        let integer_components;
+        (summary_record_input, integer_components) = nom::multi::many_m_n(
+            component_count_without_addresses as usize,
+            component_count_without_addresses as usize,
+            nn::i32(endianness),
+        )(summary_record_input)?;
+
+        let initial_address;
+        (summary_record_input, initial_address) = nn::u32(endianness)(summary_record_input)?;
+
+        let final_address;
+        (summary_record_input, final_address) = nn::u32(endianness)(summary_record_input)?;
+
+        let name;
+        (name_record_input, name) = nb::take(nc)(name_record_input)?;
+
+        summaries.push(DafSummary {
+            name: String::from_utf8_lossy(name).trim().to_string(),
+            components: DafComponents {
+                double_precision_components,
+                integer_components,
+            },
+            initial_address: initial_address as usize,
+            final_address: final_address as usize,
+        });
+    }
+
+    Ok((
+        &[],
+        DafSummaryRecord {
+            next,
+            count: nsum,
+            summaries,
+        },
+    ))
+}
+
+pub fn parse_all_summary_and_name_record_pairs(
+    input: &[u8],
+    endianness: nom::number::Endianness,
+    nd: u32,
+    ni: u32,
+    fward: u32,
+) -> nom::IResult<&[u8], Vec<DafSummaryRecord>> {
+    let mut all_summary_records = Vec::new();
+
+    let mut next = fward;
+    loop {
+        let start = ((next - 1) * RECORD_SIZE) as usize;
+        let end = ((next + 1) * RECORD_SIZE) as usize;
+
+        let summary_and_name_record_pair = &input[start..end];
+
+        let (_, summaries_record) = parse_daf_summary_and_name_record_pair(
+            summary_and_name_record_pair,
+            endianness,
+            nd,
+            ni,
+        )?;
+
+        next = summaries_record.next;
+
+        all_summary_records.push(summaries_record);
+
+        if next == 0 {
+            break;
+        }
+    }
+
+    Ok((&[], all_summary_records))
+}
+
+pub fn parse_daf_spk(full_input: &[u8]) -> Result<Spk, DafSpkError> {
+    // - https://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/req/daf.html
+    // - https://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/req/spk.html
+    // - https://naif.jpl.nasa.gov/pub/naif/toolkit_docs/Tutorials/office/individual_docs/42_making_an_spk.pptx
+
+    let input_cursor = full_input;
+
+    let (input_cursor, (endianness, file_record)) = parse_daf_file_record(input_cursor)?;
+
+    let (_, comment) = parse_daf_comment_area(input_cursor, file_record.fward - 2)?;
+
+    let (_, all_summaries) = parse_all_summary_and_name_record_pairs(
+        full_input,
+        endianness,
+        file_record.nd,
+        file_record.ni,
+        file_record.fward,
+    )?;
+
+    let segments: HashMap<BodyId, HashMap<BodyId, Vec<SpkSegment>>> = all_summaries
+        .iter()
+        .map(|summary_record| {
+            summary_record
+                .summaries
+                .iter()
+                .map(|summary| parse_spk_segment(summary, full_input, endianness))
+                .collect::<Result<Vec<SpkSegment>, DafSpkError>>()
+        })
+        .collect::<Result<Vec<_>, DafSpkError>>()?
+        .into_iter()
+        .flatten()
+        .fold(HashMap::new(), |mut map, segment| {
+            map.entry(segment.center_id)
+                .or_default()
+                .entry(segment.target_id)
+                .or_default()
+                .push(segment);
+
+            map
+        });
+
+    Ok(Spk {
+        file_record,
+        comment,
+        segments,
+    })
+}
+
+impl<I> From<nom::error::Error<I>> for DafSpkError {
+    fn from(_: nom::error::Error<I>) -> Self {
+        DafSpkError::UnableToParse
+    }
+}
+
+impl<I> From<nom::Err<I>> for DafSpkError {
+    fn from(_: nom::Err<I>) -> Self {
+        DafSpkError::UnableToParse
+    }
+}
+
+fn degree_of_chebyshev_polynomial(rsize: u32) -> u32 {
+    (rsize - 2) / 3
+}
+
+pub fn parse_spk_segment(
+    summary: &DafSummary,
+    full_input: &[u8],
+    endianness: nom::number::Endianness,
+) -> Result<SpkSegment, DafSpkError> {
+    let double_precision_components = &summary.components.double_precision_components;
+    let integer_components = &summary.components.integer_components;
+
+    if double_precision_components.len() != 2 {
+        return Err(DafSpkError::UnexpectedNumberOfComponents);
+    }
+
+    // The 2 is for initial address and final address
+    if integer_components.len() + 2 != 6 {
+        return Err(DafSpkError::UnexpectedNumberOfComponents);
+    }
+
+    let data_type = summary.components.integer_components[3];
+    let initial_address = summary.initial_address;
+    let final_address = summary.final_address;
+
+    let data = match data_type {
+        2 => {
+            let size_of_f64 = std::mem::size_of::<f64>();
+
+            // Words are 1-indexed
+            let start_word = initial_address - 1;
+            let initial_byte_address = start_word * size_of_f64;
+
+            let final_word = final_address;
+            let final_byte_address = final_word * size_of_f64;
+
+            let directory_initial_address = final_byte_address - 4 * size_of_f64;
+            let directory_data = &full_input[directory_initial_address..final_byte_address];
+
+            let f64_parser = nn::f64::<&[u8], nom::error::Error<_>>(endianness);
+
+            let (directory_data, init) = f64_parser(directory_data)?;
+            let (directory_data, intlen) = f64_parser(directory_data)?;
+            let (directory_data, rsize) = f64_parser(directory_data)?;
+            let (_, n) = f64_parser(directory_data)?;
+
+            let init = init as u32;
+            let intlen = intlen as u32;
+            let rsize = rsize as u32;
+            let n = n as u32;
+
+            let degree_of_polynomial = degree_of_chebyshev_polynomial(rsize);
+
+            let mut segment_data = &full_input[initial_byte_address..final_byte_address];
+
+            let mut records: Vec<Vec<SpkType2Coefficients>> = Vec::with_capacity(n as usize);
+
+            for _ in 0..n {
+                // MID and RADIUS seem to be generally ignored in the industry
+                (segment_data, _) = f64_parser(segment_data)?;
+                (segment_data, _) = f64_parser(segment_data)?;
+
+                // Possibly not the most efficient way of parsing since this can likely trigger
+                // tons of allocations
+                let x_coeff;
+                (segment_data, x_coeff) = nom::multi::many_m_n(
+                    degree_of_polynomial as usize,
+                    degree_of_polynomial as usize,
+                    f64_parser,
+                )(segment_data)?;
+
+                let y_coeff;
+                (segment_data, y_coeff) = nom::multi::many_m_n(
+                    degree_of_polynomial as usize,
+                    degree_of_polynomial as usize,
+                    f64_parser,
+                )(segment_data)?;
+
+                let z_coeff;
+                (segment_data, z_coeff) = nom::multi::many_m_n(
+                    degree_of_polynomial as usize,
+                    degree_of_polynomial as usize,
+                    f64_parser,
+                )(segment_data)?;
+
+                let zipped_coefficients: Vec<_> = zip(x_coeff, y_coeff)
+                    .zip(z_coeff)
+                    .map(|((x, y), z)| SpkType2Coefficients { x, y, z })
+                    .collect();
+
+                records.push(zipped_coefficients);
+            }
+
+            SpkArray::Type2(SpkType2Array {
+                records,
+                init,
+                intlen,
+                rsize,
+                n,
+            })
+        }
+        _ => return Err(DafSpkError::UnsupportedSpkArrayType { data_type }),
+    };
+
+    Ok(SpkSegment {
+        name: summary.name.clone(),
+        initial_epoch: double_precision_components[0],
+        final_epoch: double_precision_components[1],
+        target_id: integer_components[0],
+        center_id: integer_components[1],
+        reference_frame_id: integer_components[2],
+        data_type: integer_components[3],
+        initial_address: summary.initial_address,
+        final_address: summary.final_address,
+        data,
+    })
+}
+
+#[cfg(test)]
+pub mod test {
+    use super::*;
+
+    #[test]
+    fn test_parse_all_summary_and_name_record_pairs() {
+        let (_, all_summary_records) = parse_all_summary_and_name_record_pairs(
+            &FILE_CONTENTS,
+            nom::number::Endianness::Little,
+            2,
+            6,
+            4,
+        )
+        .expect("DafSummary record parsing should succeed");
+
+        assert_eq!(all_summary_records, vec![get_expected_summary_record()]);
+    }
+
+    #[test]
+    fn test_parse_daf_summary_and_name_record_pair() {
+        let (_, summary_record) = parse_daf_summary_and_name_record_pair(
+            &FILE_CONTENTS[3072..5120],
+            nom::number::Endianness::Little,
+            2,
+            6,
+        )
+        .expect("DafSummary record parsing should succeed");
+
+        assert_eq!(summary_record, get_expected_summary_record());
+    }
+
+    #[test]
+    fn test_parse_daf_comment_area() {
+        let (unparsed_string, comment) = parse_daf_comment_area(&FILE_CONTENTS[1024..3072], 2)
+            .expect("Comment area parsing should succeed");
+
+        assert_eq!(unparsed_string.len(), 0);
+
+        assert_eq!(get_expected_comment_string(), comment);
+    }
+
+    #[test]
+    fn test_parse_daf_file_record() {
+        let (unparsed_string, (endianness, file_record)) =
+            parse_daf_file_record(&FILE_CONTENTS[..1024])
+                .expect("File record parsing should succeed");
+
+        assert_eq!(unparsed_string.len(), 0);
+
+        assert_eq!(endianness, nom::number::Endianness::Little);
+        assert_eq!(file_record.locidw, "DAF/SPK");
+        assert_eq!(file_record.nd, 2);
+        assert_eq!(file_record.ni, 6);
+        assert_eq!(file_record.locifn, "NIO2SPK");
+        assert_eq!(file_record.fward, 4);
+        assert_eq!(file_record.bward, 4);
+        assert_eq!(file_record.free, 14967465);
+        assert_eq!(file_record.locfmt, "LTL-IEEE");
+        assert_eq!(
+            file_record.ftpstr,
+            b"FTPSTR:\r:\n:\r\n:\r\x00:\x81:\x10\xce:ENDFTP"
+        );
+    }
+
+    #[test]
+    fn test_parse_daf_spk() {
+        let spk = parse_daf_spk(&FILE_CONTENTS);
+
+        assert!(spk.is_ok());
+
+        if let Ok(spk) = spk {
+            assert_eq!(spk, get_expected_spk());
+        }
+    }
+
+    #[ignore]
+    #[test]
+    fn test_parse_daf_spk_file_is_ok() {
+        let contents = std::fs::read("de430.bsp").unwrap();
+
+        assert!(parse_daf_spk(&contents).is_ok());
+    }
+
+    fn get_expected_comment_string() -> String {
+        r#"September 03, 2013
+C. Acton
+
+JPL's Solar System Dynamics Group has released two new planetary/lunar ephemerides,
+named DE430 and DE431.
+
+DE430 is now considered the official export lunar/planetary ephemeris, suitable for
+all users/uses. It's approximate time span is 1550 JAN 01 to 2650 JAN 22.
+
+If a longer time span is needed, DE431 may be used, except that the lunar ephemeris
+portion is of relatively poor accuracy outside of the time span covered by DE430.
+The time span covered by DE431 is approximately 13202 B.C. to 17191 A.D. Because de431
+is so long, leading to a huge file, it has been split into two parts having the
+approximagte time spans of:
+
+   13202 B.C. to     0
+       0      to 17191 A.D.
+
+More details about these ephemeris files are contained in accompanying documentation
+available on the NAIF server:  http://naif.jpl.nasa.gov/pub/naif/generic_kernels/spk/planets/
+
+
+Special note regarding Mars:  starting with this DE file the location of Mars' mass center
+(NAIF ID = 499) is *NOT* included; only the Mars system barycenter (ID = 4) is present.
+The offset between Mars' mass center and the Mars' system barycenter in DE403 is quite small
+--about 20 cm.--so most SPICE users could use the Mars system barycenter in place of the
+Mars mass center. However, if you wish/need to have the Mars mass center available to your
+program, you'll need to load a Mars satellite ephemeris file such as "mar097.bsp" in addition
+to DE430. Satellite ephemeris files are available from the NAIF server here:
+http://naif.jpl.nasa.gov/pub/naif/generic_kernels/spk/satellites/
+
+
+Details about SPICE planet and satellite ephemeris files, known as SPK files, including
+how to read them using SPICE Toolkit software, may be found in the SPK tutorial (PDF file
+name is "19_spk") available from the NAIF website (http://naif.jpl.nasa.gov/tutorials.html)."#
+            .to_string()
+    }
+
+    pub fn get_expected_segments() -> HashMap<i32, HashMap<i32, Vec<SpkSegment>>> {
+        let mut segments: HashMap<i32, HashMap<i32, Vec<SpkSegment>>> = HashMap::new();
+
+        segments
+            .entry(0)
+            .or_default()
+            .entry(1)
+            .or_default()
+            .push(SpkSegment {
+                name: "DE-0430LE-0430".to_string(),
+                initial_epoch: -14200747200.0,
+                final_epoch: 20514081600.0,
+                target_id: 1,
+                center_id: 0,
+                reference_frame_id: 1,
+                data_type: 2,
+                initial_address: 641,
+                final_address: 1280,
+                data: SpkArray::Type2(SpkType2Array {
+                    records: vec![
+                        vec![
+                            SpkType2Coefficients {
+                                x: -45337598.32712886,
+                                y: 19369938.44656301,
+                                z: 15085572.533729337,
+                            },
+                            SpkType2Coefficients {
+                                x: -11420944.697258519,
+                                y: -12637982.109486885,
+                                z: -5541486.962461706,
+                            },
+                            SpkType2Coefficients {
+                                x: 1231640.8337434675,
+                                y: -560491.1149804397,
+                                z: -428280.81049458525,
+                            },
+                            SpkType2Coefficients {
+                                x: 13474.686621275972,
+                                y: 75269.27662838619,
+                                z: 38734.16963615925,
+                            },
+                            SpkType2Coefficients {
+                                x: -4516.487838379613,
+                                y: -1778.1593562220773,
+                                z: -474.28100346732754,
+                            },
+                            SpkType2Coefficients {
+                                x: 255.92773698003953,
+                                y: -139.11079477516455,
+                                z: -101.07262002208887,
+                            },
+                            SpkType2Coefficients {
+                                x: -0.6852704163869968,
+                                y: 18.589407873398255,
+                                z: 9.987607796726845,
+                            },
+                            SpkType2Coefficients {
+                                x: -1.186289041290495,
+                                y: -0.8470749615056106,
+                                z: -0.32728192683015445,
+                            },
+                            SpkType2Coefficients {
+                                x: 0.10359080691773931,
+                                y: -0.025136377951734054,
+                                z: -0.024284067540919708,
+                            },
+                            SpkType2Coefficients {
+                                x: -0.0024450355914312806,
+                                y: 0.006832845296274551,
+                                z: 0.003901376147416767,
+                            },
+                            SpkType2Coefficients {
+                                x: -0.00037984826619000424,
+                                y: -0.0004590535913385917,
+                                z: -0.00020497975331372796,
+                            },
+                            SpkType2Coefficients {
+                                x: 4.866121203130994e-5,
+                                y: 5.317851604321568e-7,
+                                z: -4.825361414826083e-6,
+                            },
+                            SpkType2Coefficients {
+                                x: -2.0940028772635746e-6,
+                                y: 2.763684192830889e-6,
+                                z: 1.693948385546482e-6,
+                            },
+                            SpkType2Coefficients {
+                                x: -1.1128208160400393e-7,
+                                y: -2.5800884045558593e-7,
+                                z: -1.2582686566933554e-7,
+                            },
+                        ],
+                        vec![
+                            SpkType2Coefficients {
+                                x: -58449569.351693176,
+                                y: -7935720.979204208,
+                                z: 1898385.1942239169,
+                            },
+                            SpkType2Coefficients {
+                                x: -1800097.6887639922,
+                                y: -14086536.219809037,
+                                z: -7324265.976069875,
+                            },
+                            SpkType2Coefficients {
+                                x: 1107930.6023072726,
+                                y: 136926.39656623837,
+                                z: -43287.182419830104,
+                            },
+                            SpkType2Coefficients {
+                                x: -24766.34259255632,
+                                y: 40936.67997869476,
+                                z: 24436.04346304577,
+                            },
+                            SpkType2Coefficients {
+                                x: -809.5258644486346,
+                                y: -1916.2731958592562,
+                                z: -937.1533465759844,
+                            },
+                            SpkType2Coefficients {
+                                x: 99.12917700968808,
+                                y: 54.90763068538223,
+                                z: 18.88014753122729,
+                            },
+                            SpkType2Coefficients {
+                                x: -6.248044618744813,
+                                y: 0.9048995628056529,
+                                z: 1.1386722295041676,
+                            },
+                            SpkType2Coefficients {
+                                x: 0.21641713799729656,
+                                y: -0.2509084134758946,
+                                z: -0.15655757537582016,
+                            },
+                            SpkType2Coefficients {
+                                x: 0.0016499751844322543,
+                                y: 0.019117773815199555,
+                                z: 0.010024257990951446,
+                            },
+                            SpkType2Coefficients {
+                                x: -0.0009274510372131162,
+                                y: -0.0008500801852717656,
+                                z: -0.0003560607620357178,
+                            },
+                            SpkType2Coefficients {
+                                x: 8.000372257212273e-5,
+                                y: 7.62770401533323e-6,
+                                z: -4.331049116694897e-6,
+                            },
+                            SpkType2Coefficients {
+                                x: -3.9756072002001035e-6,
+                                y: 2.5586829899051993e-6,
+                                z: 1.7821740868686663e-6,
+                            },
+                            SpkType2Coefficients {
+                                x: 6.145431105172551e-8,
+                                y: -2.753091189940317e-7,
+                                z: -1.5334346647775201e-7,
+                            },
+                            SpkType2Coefficients {
+                                x: 1.0008661455878206e-8,
+                                y: 1.6453893506401273e-8,
+                                z: 7.655421689274075e-9,
+                            },
+                        ],
+                        vec![
+                            SpkType2Coefficients {
+                                x: -54210897.94074123,
+                                y: -33770751.31370555,
+                                z: -12326047.807205081,
+                            },
+                            SpkType2Coefficients {
+                                x: 5761909.474302993,
+                                y: -11464200.40064359,
+                                z: -6719455.6659584055,
+                            },
+                            SpkType2Coefficients {
+                                x: 777406.6366812486,
+                                y: 480029.461654695,
+                                z: 174427.62741919362,
+                            },
+                            SpkType2Coefficients {
+                                x: -28073.762491013582,
+                                y: 18778.161983893195,
+                                z: 12963.860927714393,
+                            },
+                            SpkType2Coefficients {
+                                x: 121.63964967772013,
+                                y: -916.1483800707576,
+                                z: -501.4481801676182,
+                            },
+                            SpkType2Coefficients {
+                                x: 12.083715502838807,
+                                y: 37.85101299123708,
+                                z: 18.921171942332254,
+                            },
+                            SpkType2Coefficients {
+                                x: -1.653002384389899,
+                                y: -1.1948239135585854,
+                                z: -0.46377127345030145,
+                            },
+                            SpkType2Coefficients {
+                                x: 0.09122771149628371,
+                                y: 0.009935203283866965,
+                                z: -0.004278716845379022,
+                            },
+                            SpkType2Coefficients {
+                                x: -0.0039806132479455955,
+                                y: 0.0016042528603672538,
+                                z: 0.0012736474960823164,
+                            },
+                            SpkType2Coefficients {
+                                x: 0.00011090320124970714,
+                                y: -0.00016422253688236636,
+                                z: -9.924063032619023e-5,
+                            },
+                            SpkType2Coefficients {
+                                x: 3.208770532420429e-7,
+                                y: 9.711085809982569e-6,
+                                z: 5.146289420109514e-6,
+                            },
+                            SpkType2Coefficients {
+                                x: -3.086111778410841e-7,
+                                y: -4.246183965796327e-7,
+                                z: -1.9415079840488192e-7,
+                            },
+                            SpkType2Coefficients {
+                                x: 2.5750271455539576e-8,
+                                y: 1.1851050800781965e-8,
+                                z: 3.450896117737893e-9,
+                            },
+                            SpkType2Coefficients {
+                                x: -1.1242975305362077e-9,
+                                y: 3.905894854894403e-10,
+                                z: 1.819059570466293e-10,
+                            },
+                        ],
+                        vec![
+                            SpkType2Coefficients {
+                                x: -37505891.58733246,
+                                y: -52289262.29241685,
+                                z: -23956693.94508471,
+                            },
+                            SpkType2Coefficients {
+                                x: 10674488.54339679,
+                                y: -6923680.138903326,
+                                z: -4813309.998691719,
+                            },
+                            SpkType2Coefficients {
+                                x: 455040.0736010689,
+                                y: 637750.5106004501,
+                                z: 292402.5132673988,
+                            },
+                            SpkType2Coefficients {
+                                x: -25695.24376738423,
+                                y: 8767.195085224153,
+                                z: 7374.247209604691,
+                            },
+                            SpkType2Coefficients {
+                                x: 113.81703928594601,
+                                y: -409.200548600714,
+                                z: -230.21909153218752,
+                            },
+                            SpkType2Coefficients {
+                                x: -7.925717470323576,
+                                y: 14.79991761561071,
+                                z: 8.726464815796334,
+                            },
+                            SpkType2Coefficients {
+                                x: -0.34514522809375564,
+                                y: -0.7183818860227476,
+                                z: -0.3469500588730363,
+                            },
+                            SpkType2Coefficients {
+                                x: 0.0176780815965851,
+                                y: 0.014210457550526053,
+                                z: 0.005723849852140356,
+                            },
+                            SpkType2Coefficients {
+                                x: -0.0010531956678777052,
+                                y: -0.00046859577877625294,
+                                z: -0.00013937389776502555,
+                            },
+                            SpkType2Coefficients {
+                                x: 4.514322215422244e-5,
+                                y: -7.592577392189398e-6,
+                                z: -8.79098050520026e-6,
+                            },
+                            SpkType2Coefficients {
+                                x: -1.4448248877522545e-6,
+                                y: 7.777434254709131e-7,
+                                z: 5.661431511840274e-7,
+                            },
+                            SpkType2Coefficients {
+                                x: 4.147204966378829e-8,
+                                y: -6.121607354123216e-8,
+                                z: -3.7012971681646134e-8,
+                            },
+                            SpkType2Coefficients {
+                                x: 6.312482379064945e-10,
+                                y: 2.661451379451677e-9,
+                                z: 1.7275326074056334e-9,
+                            },
+                            SpkType2Coefficients {
+                                x: 8.266830416632963e-11,
+                                y: -9.745279166627787e-10,
+                                z: 2.647744718956467e-12,
+                            },
+                        ],
+                        vec![
+                            SpkType2Coefficients {
+                                x: -13480566.556582376,
+                                y: -60768703.66295594,
+                                z: -31001044.578021735,
+                            },
+                            SpkType2Coefficients {
+                                x: 13098038.480735628,
+                                y: -1495202.6867775493,
+                                z: -2172196.746889192,
+                            },
+                            SpkType2Coefficients {
+                                x: 151264.9806054996,
+                                y: 710699.0281462192,
+                                z: 363207.4374640283,
+                            },
+                            SpkType2Coefficients {
+                                x: -25476.58030891933,
+                                y: 3754.081219384137,
+                                z: 4677.273311438741,
+                            },
+                            SpkType2Coefficients {
+                                x: -101.92493293828662,
+                                y: -262.7478808422509,
+                                z: -129.4495768022601,
+                            },
+                            SpkType2Coefficients {
+                                x: -12.889820450709234,
+                                y: 0.5057165515555004,
+                                z: 1.6230758048764975,
+                            },
+                            SpkType2Coefficients {
+                                x: -0.13746956986424033,
+                                y: -0.5501353335248234,
+                                z: -0.2790110353336393,
+                            },
+                            SpkType2Coefficients {
+                                x: 0.0021899860484605447,
+                                y: -0.0026423962154335386,
+                                z: -0.0016393935905534595,
+                            },
+                            SpkType2Coefficients {
+                                x: -6.102771135850726e-5,
+                                y: -0.0005747023559221212,
+                                z: -0.0003001401197731395,
+                            },
+                            SpkType2Coefficients {
+                                x: 2.0203914290812262e-5,
+                                y: -4.427521182666183e-6,
+                                z: -4.483326811276608e-6,
+                            },
+                            SpkType2Coefficients {
+                                x: 1.2401306222838308e-7,
+                                y: -2.2608106711907944e-7,
+                                z: -1.3281815174391787e-7,
+                            },
+                            SpkType2Coefficients {
+                                x: 3.414370315475422e-8,
+                                y: -2.077889269902425e-9,
+                                z: -4.685709180488663e-9,
+                            },
+                            SpkType2Coefficients {
+                                x: 6.113933096711511e-11,
+                                y: 1.9965534065395228e-9,
+                                z: 2.0915798921278826e-10,
+                            },
+                            SpkType2Coefficients {
+                                x: -6.847536309069575e-11,
+                                y: -1.7723130627533263e-10,
+                                z: 1.0123566576788687e-10,
+                            },
+                        ],
+                        vec![
+                            SpkType2Coefficients {
+                                x: 12924374.015098413,
+                                y: -57983909.45103208,
+                                z: -32286857.994901855,
+                            },
+                            SpkType2Coefficients {
+                                x: 13036921.776594413,
+                                y: 4294940.852419956,
+                                z: 922700.2004467127,
+                            },
+                            SpkType2Coefficients {
+                                x: -173258.67460110967,
+                                y: 728370.1715333756,
+                                z: 406705.6026941626,
+                            },
+                            SpkType2Coefficients {
+                                x: -29322.559968570153,
+                                y: -1151.356513103967,
+                                z: 2464.488245095452,
+                            },
+                            SpkType2Coefficients {
+                                x: -385.65279580845936,
+                                y: -402.2354970834203,
+                                z: -174.0636949697199,
+                            },
+                            SpkType2Coefficients {
+                                x: -14.886368014428252,
+                                y: -15.867069239763726,
+                                z: -6.900606389564812,
+                            },
+                            SpkType2Coefficients {
+                                x: 0.032080021355132285,
+                                y: -0.9161278285877755,
+                                z: -0.4920339971160255,
+                            },
+                            SpkType2Coefficients {
+                                x: 0.016287548681964924,
+                                y: -0.02488481245885575,
+                                z: -0.01498370326892611,
+                            },
+                            SpkType2Coefficients {
+                                x: 0.0012033591743594745,
+                                y: -0.0008160331389670967,
+                                z: -0.00056161731076134,
+                            },
+                            SpkType2Coefficients {
+                                x: 6.5773094877564e-5,
+                                y: -2.3656137324417096e-6,
+                                z: -8.1665411304901e-6,
+                            },
+                            SpkType2Coefficients {
+                                x: 2.552075542282858e-6,
+                                y: 9.062712071296104e-7,
+                                z: 2.1587896504329588e-7,
+                            },
+                            SpkType2Coefficients {
+                                x: 8.678130515258873e-8,
+                                y: 8.465577138535719e-8,
+                                z: 3.615726588487529e-8,
+                            },
+                            SpkType2Coefficients {
+                                x: 1.4424526593101816e-9,
+                                y: 4.27633127160829e-9,
+                                z: 1.8867080135302315e-9,
+                            },
+                            SpkType2Coefficients {
+                                x: 8.481561628175781e-11,
+                                y: 6.586099007446288e-10,
+                                z: 6.753822366729298e-11,
+                            },
+                        ],
+                        vec![
+                            SpkType2Coefficients {
+                                x: 36409830.50565798,
+                                y: -43709674.23762289,
+                                z: -27137646.95744377,
+                            },
+                            SpkType2Coefficients {
+                                x: 10117327.079638528,
+                                y: 9923967.547431879,
+                                z: 4231773.3597003305,
+                            },
+                            SpkType2Coefficients {
+                                x: -571151.4194038364,
+                                y: 660828.826202368,
+                                z: 412454.2316412725,
+                            },
+                            SpkType2Coefficients {
+                                x: -37563.17926341247,
+                                y: -11606.941139804172,
+                                z: -2247.364291950567,
+                            },
+                            SpkType2Coefficients {
+                                x: -603.7807025768652,
+                                y: -1009.6836691174926,
+                                z: -475.17709608369734,
+                            },
+                            SpkType2Coefficients {
+                                x: -1.2081752304636253,
+                                y: -48.710551192440604,
+                                z: -25.85553272787237,
+                            },
+                            SpkType2Coefficients {
+                                x: 1.568028009732732,
+                                y: -1.870529516169376,
+                                z: -1.1623769344020758,
+                            },
+                            SpkType2Coefficients {
+                                x: 0.11981831128613148,
+                                y: -0.031933651917395375,
+                                z: -0.029613442794534588,
+                            },
+                            SpkType2Coefficients {
+                                x: 0.006256803697846111,
+                                y: 0.0016547091763384166,
+                                z: 0.00022571479137512476,
+                            },
+                            SpkType2Coefficients {
+                                x: 0.0002222552080839927,
+                                y: 0.00023129741041829377,
+                                z: 0.000100040492847673,
+                            },
+                            SpkType2Coefficients {
+                                x: 2.371661165742397e-6,
+                                y: 1.544835685314219e-5,
+                                z: 7.990148218873311e-6,
+                            },
+                            SpkType2Coefficients {
+                                x: -4.1003984878706727e-7,
+                                y: 7.233327555162387e-7,
+                                z: 4.2883476302382474e-7,
+                            },
+                            SpkType2Coefficients {
+                                x: -4.246271385183673e-8,
+                                y: 1.9237101443426504e-8,
+                                z: 1.5763466794390723e-8,
+                            },
+                            SpkType2Coefficients {
+                                x: -2.140884834622074e-9,
+                                y: -4.723400496382733e-10,
+                                z: -2.856720293690054e-10,
+                            },
+                        ],
+                        vec![
+                            SpkType2Coefficients {
+                                x: 50543722.086727604,
+                                y: -19269185.716454018,
+                                z: -15583889.594508631,
+                            },
+                            SpkType2Coefficients {
+                                x: 3599931.8894646326,
+                                y: 14288380.206906335,
+                                z: 7244035.831173811,
+                            },
+                            SpkType2Coefficients {
+                                x: -1069755.3628819815,
+                                y: 384319.4620373969,
+                                z: 317312.37891250395,
+                            },
+                            SpkType2Coefficients {
+                                x: -43737.09886475732,
+                                y: -38037.15054279719,
+                                z: -15697.124584282366,
+                            },
+                            SpkType2Coefficients {
+                                x: 164.97450012878275,
+                                y: -2420.636919948095,
+                                z: -1308.4974377707993,
+                            },
+                            SpkType2Coefficients {
+                                x: 105.40651375456635,
+                                y: -84.68688187104273,
+                                z: -56.23908543773916,
+                            },
+                            SpkType2Coefficients {
+                                x: 8.55469813080309,
+                                y: 0.4731449232651164,
+                                z: -0.645794473447411,
+                            },
+                            SpkType2Coefficients {
+                                x: 0.36590467785850955,
+                                y: 0.33945733423292934,
+                                z: 0.14265082540796215,
+                            },
+                            SpkType2Coefficients {
+                                x: 0.0007971678655988924,
+                                y: 0.02848960090423228,
+                                z: 0.01511275828687557,
+                            },
+                            SpkType2Coefficients {
+                                x: -0.0013822344209006461,
+                                y: 0.0012747729527165339,
+                                z: 0.0008250912189995393,
+                            },
+                            SpkType2Coefficients {
+                                x: -0.00013287000051370035,
+                                y: 1.2336704218421914e-6,
+                                z: 1.4607793651668574e-5,
+                            },
+                            SpkType2Coefficients {
+                                x: -6.7162339643467585e-6,
+                                y: -5.356377894611242e-6,
+                                z: -2.1519526344664532e-6,
+                            },
+                            SpkType2Coefficients {
+                                x: -5.9391362124116395e-8,
+                                y: -5.226237790409592e-7,
+                                z: -2.720837114530803e-7,
+                            },
+                            SpkType2Coefficients {
+                                x: 2.4000988068303212e-8,
+                                y: -2.723298390425405e-8,
+                                z: -1.6915798221638822e-8,
+                            },
+                        ],
+                        vec![
+                            SpkType2Coefficients {
+                                x: 47715161.385413,
+                                y: 10404753.329928415,
+                                z: 542318.7750979952,
+                            },
+                            SpkType2Coefficients {
+                                x: -6765836.899970185,
+                                y: 14779071.692198437,
+                                z: 8594088.428959873,
+                            },
+                            SpkType2Coefficients {
+                                x: -1465606.5161023152,
+                                y: -344210.7030515934,
+                                z: -29727.188744053525,
+                            },
+                            SpkType2Coefficients {
+                                x: -10581.87372964701,
+                                y: -84226.8052209682,
+                                z: -43815.874113158745,
+                            },
+                            SpkType2Coefficients {
+                                x: 4807.211552791774,
+                                y: -2583.8778640813425,
+                                z: -1882.9667458416272,
+                            },
+                            SpkType2Coefficients {
+                                x: 343.9710037358144,
+                                y: 164.8115854848478,
+                                z: 51.797012526487116,
+                            },
+                            SpkType2Coefficients {
+                                x: 2.4246758636389076,
+                                y: 24.30539430978275,
+                                z: 12.710013263635187,
+                            },
+                            SpkType2Coefficients {
+                                x: -1.648672697688401,
+                                y: 0.9842641323600833,
+                                z: 0.6981068201687447,
+                            },
+                            SpkType2Coefficients {
+                                x: -0.14393165092324786,
+                                y: -0.061475986403702304,
+                                z: -0.017679892337270447,
+                            },
+                            SpkType2Coefficients {
+                                x: -0.0016606957917306442,
+                                y: -0.010940818407565325,
+                                z: -0.005661512737256319,
+                            },
+                            SpkType2Coefficients {
+                                x: 0.0007746124393387002,
+                                y: -0.0005148133372302519,
+                                z: -0.0003559310741837079,
+                            },
+                            SpkType2Coefficients {
+                                x: 7.591369608267796e-5,
+                                y: 2.851152275335745e-5,
+                                z: 7.237817810727936e-6,
+                            },
+                            SpkType2Coefficients {
+                                x: 1.2175945888890173e-6,
+                                y: 5.894372589974007e-6,
+                                z: 3.016221773585502e-6,
+                            },
+                            SpkType2Coefficients {
+                                x: -4.1804046500567263e-7,
+                                y: 3.1205490724883324e-7,
+                                z: 2.105018407145734e-7,
+                            },
+                        ],
+                        vec![
+                            SpkType2Coefficients {
+                                x: 23270918.979379125,
+                                y: 33815823.653189495,
+                                z: 15597350.020431643,
+                            },
+                            SpkType2Coefficients {
+                                x: -17256716.368954264,
+                                y: 7748953.55497174,
+                                z: 5945649.545798879,
+                            },
+                            SpkType2Coefficients {
+                                x: -954598.9755969029,
+                                y: -1386443.8244291213,
+                                z: -639309.6247786926,
+                            },
+                            SpkType2Coefficients {
+                                x: 101869.74273592202,
+                                y: -67045.26641936596,
+                                z: -46457.66020202247,
+                            },
+                            SpkType2Coefficients {
+                                x: 6770.864790225536,
+                                y: 6049.759734071041,
+                                z: 2516.0791556047075,
+                            },
+                            SpkType2Coefficients {
+                                x: -404.3473796217518,
+                                y: 507.3469545124919,
+                                z: 313.07375838137585,
+                            },
+                            SpkType2Coefficients {
+                                x: -52.99753919509793,
+                                y: -24.538365698424087,
+                                z: -7.524554482312445,
+                            },
+                            SpkType2Coefficients {
+                                x: 1.3691602972264172,
+                                y: -4.219212112047788,
+                                z: -2.394293188546936,
+                            },
+                            SpkType2Coefficients {
+                                x: 0.43925632684682697,
+                                y: 0.06532388690975224,
+                                z: -0.011274242477285907,
+                            },
+                            SpkType2Coefficients {
+                                x: 0.0018346172940959047,
+                                y: 0.03561010180824766,
+                                z: 0.018801936763089475,
+                            },
+                            SpkType2Coefficients {
+                                x: -0.0036142809423915173,
+                                y: 0.0005128648992871837,
+                                z: 0.0006530328448389293,
+                            },
+                            SpkType2Coefficients {
+                                x: -0.00012491773418058397,
+                                y: -0.000292314096541678,
+                                z: -0.00014280604054292342,
+                            },
+                            SpkType2Coefficients {
+                                x: 2.828142086444596e-5,
+                                y: -1.34486238229468e-5,
+                                z: -1.0142372145929214e-5,
+                            },
+                            SpkType2Coefficients {
+                                x: 2.02650433691657e-6,
+                                y: 2.252218889725443e-6,
+                                z: 9.883364952693398e-7,
+                            },
+                        ],
+                        vec![
+                            SpkType2Coefficients {
+                                x: -14302112.478480183,
+                                y: 37127769.12752547,
+                                z: 21309842.14818654,
+                            },
+                            SpkType2Coefficients {
+                                x: -19069919.56448197,
+                                y: -4490458.993168776,
+                                z: -392529.49609443726,
+                            },
+                            SpkType2Coefficients {
+                                x: 515204.77798256016,
+                                y: -1451652.0030301881,
+                                z: -828409.079766861,
+                            },
+                            SpkType2Coefficients {
+                                x: 110060.69037873248,
+                                y: 54873.151509303076,
+                                z: 17714.073679264868,
+                            },
+                            SpkType2Coefficients {
+                                x: -5580.825240276621,
+                                y: 5639.915091025177,
+                                z: 3594.2903651668257,
+                            },
+                            SpkType2Coefficients {
+                                x: -370.2192777295126,
+                                y: -490.94873651444885,
+                                z: -223.0038885814632,
+                            },
+                            SpkType2Coefficients {
+                                x: 48.86063157915018,
+                                y: -13.34508901391277,
+                                z: -12.24827254781346,
+                            },
+                            SpkType2Coefficients {
+                                x: 0.3433868526053941,
+                                y: 3.8672966862522746,
+                                z: 2.0267775252913185,
+                            },
+                            SpkType2Coefficients {
+                                x: -0.3689733210882523,
+                                y: -0.07771483028641848,
+                                z: -0.002714236959790189,
+                            },
+                            SpkType2Coefficients {
+                                x: 0.014424822977178191,
+                                y: -0.025988013547959172,
+                                z: -0.015376585582127298,
+                            },
+                            SpkType2Coefficients {
+                                x: 0.0022704585183469296,
+                                y: 0.0018455519765964191,
+                                z: 0.0007460432824687185,
+                            },
+                            SpkType2Coefficients {
+                                x: -0.00022821024420895437,
+                                y: 0.00012668340451298506,
+                                z: 9.15335244786352e-5,
+                            },
+                            SpkType2Coefficients {
+                                x: -8.276206806577387e-6,
+                                y: -2.1807579234944036e-5,
+                                z: -1.0761861493761696e-5,
+                            },
+                            SpkType2Coefficients {
+                                x: 2.406031793142807e-6,
+                                y: -2.723247702600162e-8,
+                                z: -2.6722360449168746e-7,
+                            },
+                        ],
+                        vec![
+                            SpkType2Coefficients {
+                                x: -45350344.168980576,
+                                y: 19224804.86125569,
+                                z: 15021167.722862277,
+                            },
+                            SpkType2Coefficients {
+                                x: -11383349.691344053,
+                                y: -12654718.156929357,
+                                z: -5554404.770343297,
+                            },
+                            SpkType2Coefficients {
+                                x: 1232277.6392773716,
+                                y: -557057.1528215639,
+                                z: -426515.7808066775,
+                            },
+                            SpkType2Coefficients {
+                                x: 13199.32536501195,
+                                y: 75163.12522116388,
+                                z: 38706.450957135254,
+                            },
+                            SpkType2Coefficients {
+                                x: -4497.195208447304,
+                                y: -1788.8134345085332,
+                                z: -481.9905832453785,
+                            },
+                            SpkType2Coefficients {
+                                x: 255.87672676675095,
+                                y: -137.42397399685794,
+                                z: -100.1671973654519,
+                            },
+                            SpkType2Coefficients {
+                                x: -0.8110886216898764,
+                                y: 18.500243622033917,
+                                z: 9.95325478448965,
+                            },
+                            SpkType2Coefficients {
+                                x: -1.1737944602604822,
+                                y: -0.8501479177967093,
+                                z: -0.33023485740428854,
+                            },
+                            SpkType2Coefficients {
+                                x: 0.10326061177793994,
+                                y: -0.0242070325118841,
+                                z: -0.023753716920769462,
+                            },
+                            SpkType2Coefficients {
+                                x: -0.0025024315740898176,
+                                y: 0.006763728015186381,
+                                z: 0.003870542044050555,
+                            },
+                            SpkType2Coefficients {
+                                x: -0.0003717686519532686,
+                                y: -0.00045897874910957024,
+                                z: -0.000205785685419332,
+                            },
+                            SpkType2Coefficients {
+                                x: 4.828213004613172e-5,
+                                y: 1.0308151299535684e-6,
+                                z: -4.519405769857414e-6,
+                            },
+                            SpkType2Coefficients {
+                                x: -2.1153006377942852e-6,
+                                y: 2.714271798917107e-6,
+                                z: 1.6694911193365625e-6,
+                            },
+                            SpkType2Coefficients {
+                                x: -1.0663734226988474e-7,
+                                y: -2.567848133727514e-7,
+                                z: -1.2542045425680128e-7,
+                            },
+                        ],
+                        vec![
+                            SpkType2Coefficients {
+                                x: -58389226.22256667,
+                                y: -8091714.337427627,
+                                z: 1820428.2065686637,
+                            },
+                            SpkType2Coefficients {
+                                x: -1766054.6052030046,
+                                y: -14081973.652760211,
+                                z: -7325448.793696021,
+                            },
+                            SpkType2Coefficients {
+                                x: 1106801.4567413135,
+                                y: 138810.8374249616,
+                                z: -42163.3093941699,
+                            },
+                            SpkType2Coefficients {
+                                x: -24817.014284937664,
+                                y: 40820.06424547664,
+                                z: 24379.16666021187,
+                            },
+                            SpkType2Coefficients {
+                                x: -801.9509565938666,
+                                y: -1912.170569517239,
+                                z: -935.7589059008715,
+                            },
+                            SpkType2Coefficients {
+                                x: 98.56190425937514,
+                                y: 54.99316570351528,
+                                z: 18.985238953105736,
+                            },
+                            SpkType2Coefficients {
+                                x: -6.225307809265943,
+                                y: 0.8782851315752163,
+                                z: 1.1220799638909078,
+                            },
+                            SpkType2Coefficients {
+                                x: 0.2166308405314536,
+                                y: -0.248596524127064,
+                                z: -0.1553450736857643,
+                            },
+                            SpkType2Coefficients {
+                                x: 0.0015235918031991618,
+                                y: 0.019001665693900285,
+                                z: 0.009975562024603925,
+                            },
+                            SpkType2Coefficients {
+                                x: -0.0009154264174046048,
+                                y: -0.000848901463675118,
+                                z: -0.0003567131372449493,
+                            },
+                            SpkType2Coefficients {
+                                x: 7.934582987812358e-5,
+                                y: 8.060030376793692e-6,
+                                z: -4.030172364414252e-6,
+                            },
+                            SpkType2Coefficients {
+                                x: -3.963710165920319e-6,
+                                y: 2.5078948861037383e-6,
+                                z: 1.7540449870050126e-6,
+                            },
+                            SpkType2Coefficients {
+                                x: 6.36383573374082e-8,
+                                y: -2.7242476898255323e-7,
+                                z: -1.5196790376014343e-7,
+                            },
+                            SpkType2Coefficients {
+                                x: 9.61362055440764e-9,
+                                y: 1.594140293923078e-8,
+                                z: 7.630701672941777e-9,
+                            },
+                        ],
+                        vec![
+                            SpkType2Coefficients {
+                                x: -54092426.04345092,
+                                y: -33906193.5251241,
+                                z: -12399228.667557947,
+                            },
+                            SpkType2Coefficients {
+                                x: 5785867.736703381,
+                                y: -11449057.168716598,
+                                z: -6713934.131973944,
+                            },
+                            SpkType2Coefficients {
+                                x: 776112.1568083934,
+                                y: 480896.6728461073,
+                                z: 175026.40877961094,
+                            },
+                            SpkType2Coefficients {
+                                x: -28066.908030287876,
+                                y: 18721.70710881851,
+                                z: 12933.041421377007,
+                            },
+                            SpkType2Coefficients {
+                                x: 122.603506733156,
+                                y: -913.2813372009165,
+                                z: -500.02031568076006,
+                            },
+                            SpkType2Coefficients {
+                                x: 11.932401912329652,
+                                y: 37.743845357251814,
+                                z: 18.87986386969098,
+                            },
+                            SpkType2Coefficients {
+                                x: -1.6433261659736709,
+                                y: -1.193841007569472,
+                                z: -0.46425983354010003,
+                            },
+                            SpkType2Coefficients {
+                                x: 0.09074605157091184,
+                                y: 0.010130659052011168,
+                                z: -0.004124182287322653,
+                            },
+                            SpkType2Coefficients {
+                                x: -0.003965601544184511,
+                                y: 0.0015820668574517652,
+                                z: 0.0012602487340585295,
+                            },
+                            SpkType2Coefficients {
+                                x: 0.00011096505553262233,
+                                y: -0.00016276915666452104,
+                                z: -9.846948384070477e-5,
+                            },
+                            SpkType2Coefficients {
+                                x: 2.6781404333806733e-7,
+                                y: 9.640528130514774e-6,
+                                z: 5.11380993449563e-6,
+                            },
+                            SpkType2Coefficients {
+                                x: -3.037968216179319e-7,
+                                y: -4.225407856969625e-7,
+                                z: -1.9349486950740913e-7,
+                            },
+                            SpkType2Coefficients {
+                                x: 2.6331227830238215e-8,
+                                y: 1.1030750057785568e-8,
+                                z: 3.218807864676213e-9,
+                            },
+                            SpkType2Coefficients {
+                                x: -1.1234198172382371e-9,
+                                y: 5.757999958318061e-10,
+                                z: 1.9331843287510842e-10,
+                            },
+                        ],
+                    ],
+                    init: 0,
+                    intlen: 691200,
+                    rsize: 44,
+                    n: 14,
+                }),
+            });
+
+        segments
+    }
+
+    fn get_expected_spk() -> Spk {
+        // Values confirmed with JPLEphem.jp and python-jplephem
+
+        Spk {
+            file_record: DafFileRecord {
+                locidw: "DAF/SPK".to_string(),
+                nd: 2,
+                ni: 6,
+                locifn: "NIO2SPK".to_string(),
+                fward: 4,
+                bward: 4,
+                free: 14967465,
+                locfmt: "LTL-IEEE".to_string(),
+                prenul: vec![
+                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                    0, 0, 0, 0, 0,
+                ],
+                ftpstr: vec![
+                    70, 84, 80, 83, 84, 82, 58, 13, 58, 10, 58, 13, 10, 58, 13, 0, 58, 129, 58, 16,
+                    206, 58, 69, 78, 68, 70, 84, 80,
+                ],
+                pstnul: vec![
+                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                ],
+            },
+            comment: get_expected_comment_string(),
+            segments: get_expected_segments(),
+        }
+    }
+
+    fn get_expected_summary_record() -> DafSummaryRecord {
+        DafSummaryRecord {
+            next: 0,
+            count: 1,
+            summaries: vec![DafSummary {
+                name: "DE-0430LE-0430".to_string(),
+                components: DafComponents {
+                    double_precision_components: vec![-14200747200.0, 20514081600.0],
+                    integer_components: vec![1, 0, 1, 2],
+                },
+                initial_address: 641,
+                final_address: 1280,
+            }],
+        }
+    }
+
+    #[ignore]
+    #[test]
+    fn create_file_contents_array() {
+        // Use this function to generate the FILE_CONTENTS array below
+
+        let mut contents = std::fs::read("de430.bsp").unwrap();
+
+        let size_of_u32: usize = std::mem::size_of::<u32>();
+        let size_of_f64 = std::mem::size_of::<f64>();
+
+        // Override the segment count to just 1 to simplify testing
+        contents[3088..(3088 + size_of_f64)].copy_from_slice(&1f64.to_le_bytes());
+
+        // Override the final address so we can test with less data
+        let final_address = 1280usize;
+        contents[3132..(3132 + size_of_u32)].copy_from_slice(&(final_address as u32).to_le_bytes());
+
+        let final_index = final_address * size_of_f64;
+        let directory_data = &mut contents[final_index - 4 * size_of_f64..];
+
+        // Override the directory data so that the segment parser can find it
+        // We override n to be 14 instead of the original value
+        directory_data[..size_of_f64].copy_from_slice(&0f64.to_le_bytes()); // init
+        directory_data[size_of_f64..size_of_f64 * 2].copy_from_slice(&691200f64.to_le_bytes()); // intlen
+        directory_data[size_of_f64 * 2..size_of_f64 * 3].copy_from_slice(&44f64.to_le_bytes()); // rsize
+        directory_data[size_of_f64 * 3..size_of_f64 * 4].copy_from_slice(&14f64.to_le_bytes()); // n
+
+        for item in contents.iter().take(10240) {
+            print!("0x{:02X}u8, ", item);
+        }
+    }
+
+    pub const FILE_CONTENTS: [u8; 10240] = [
+        0x44u8, 0x41u8, 0x46u8, 0x2Fu8, 0x53u8, 0x50u8, 0x4Bu8, 0x20u8, 0x02u8, 0x00u8, 0x00u8,
+        0x00u8, 0x06u8, 0x00u8, 0x00u8, 0x00u8, 0x4Eu8, 0x49u8, 0x4Fu8, 0x32u8, 0x53u8, 0x50u8,
+        0x4Bu8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x04u8,
+        0x00u8, 0x00u8, 0x00u8, 0x04u8, 0x00u8, 0x00u8, 0x00u8, 0xA9u8, 0x62u8, 0xE4u8, 0x00u8,
+        0x4Cu8, 0x54u8, 0x4Cu8, 0x2Du8, 0x49u8, 0x45u8, 0x45u8, 0x45u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x46u8, 0x54u8, 0x50u8, 0x53u8, 0x54u8,
+        0x52u8, 0x3Au8, 0x0Du8, 0x3Au8, 0x0Au8, 0x3Au8, 0x0Du8, 0x0Au8, 0x3Au8, 0x0Du8, 0x00u8,
+        0x3Au8, 0x81u8, 0x3Au8, 0x10u8, 0xCEu8, 0x3Au8, 0x45u8, 0x4Eu8, 0x44u8, 0x46u8, 0x54u8,
+        0x50u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x53u8, 0x65u8, 0x70u8, 0x74u8, 0x65u8, 0x6Du8, 0x62u8, 0x65u8,
+        0x72u8, 0x20u8, 0x30u8, 0x33u8, 0x2Cu8, 0x20u8, 0x32u8, 0x30u8, 0x31u8, 0x33u8, 0x00u8,
+        0x43u8, 0x2Eu8, 0x20u8, 0x41u8, 0x63u8, 0x74u8, 0x6Fu8, 0x6Eu8, 0x00u8, 0x00u8, 0x4Au8,
+        0x50u8, 0x4Cu8, 0x27u8, 0x73u8, 0x20u8, 0x53u8, 0x6Fu8, 0x6Cu8, 0x61u8, 0x72u8, 0x20u8,
+        0x53u8, 0x79u8, 0x73u8, 0x74u8, 0x65u8, 0x6Du8, 0x20u8, 0x44u8, 0x79u8, 0x6Eu8, 0x61u8,
+        0x6Du8, 0x69u8, 0x63u8, 0x73u8, 0x20u8, 0x47u8, 0x72u8, 0x6Fu8, 0x75u8, 0x70u8, 0x20u8,
+        0x68u8, 0x61u8, 0x73u8, 0x20u8, 0x72u8, 0x65u8, 0x6Cu8, 0x65u8, 0x61u8, 0x73u8, 0x65u8,
+        0x64u8, 0x20u8, 0x74u8, 0x77u8, 0x6Fu8, 0x20u8, 0x6Eu8, 0x65u8, 0x77u8, 0x20u8, 0x70u8,
+        0x6Cu8, 0x61u8, 0x6Eu8, 0x65u8, 0x74u8, 0x61u8, 0x72u8, 0x79u8, 0x2Fu8, 0x6Cu8, 0x75u8,
+        0x6Eu8, 0x61u8, 0x72u8, 0x20u8, 0x65u8, 0x70u8, 0x68u8, 0x65u8, 0x6Du8, 0x65u8, 0x72u8,
+        0x69u8, 0x64u8, 0x65u8, 0x73u8, 0x2Cu8, 0x00u8, 0x6Eu8, 0x61u8, 0x6Du8, 0x65u8, 0x64u8,
+        0x20u8, 0x44u8, 0x45u8, 0x34u8, 0x33u8, 0x30u8, 0x20u8, 0x61u8, 0x6Eu8, 0x64u8, 0x20u8,
+        0x44u8, 0x45u8, 0x34u8, 0x33u8, 0x31u8, 0x2Eu8, 0x00u8, 0x00u8, 0x44u8, 0x45u8, 0x34u8,
+        0x33u8, 0x30u8, 0x20u8, 0x69u8, 0x73u8, 0x20u8, 0x6Eu8, 0x6Fu8, 0x77u8, 0x20u8, 0x63u8,
+        0x6Fu8, 0x6Eu8, 0x73u8, 0x69u8, 0x64u8, 0x65u8, 0x72u8, 0x65u8, 0x64u8, 0x20u8, 0x74u8,
+        0x68u8, 0x65u8, 0x20u8, 0x6Fu8, 0x66u8, 0x66u8, 0x69u8, 0x63u8, 0x69u8, 0x61u8, 0x6Cu8,
+        0x20u8, 0x65u8, 0x78u8, 0x70u8, 0x6Fu8, 0x72u8, 0x74u8, 0x20u8, 0x6Cu8, 0x75u8, 0x6Eu8,
+        0x61u8, 0x72u8, 0x2Fu8, 0x70u8, 0x6Cu8, 0x61u8, 0x6Eu8, 0x65u8, 0x74u8, 0x61u8, 0x72u8,
+        0x79u8, 0x20u8, 0x65u8, 0x70u8, 0x68u8, 0x65u8, 0x6Du8, 0x65u8, 0x72u8, 0x69u8, 0x73u8,
+        0x2Cu8, 0x20u8, 0x73u8, 0x75u8, 0x69u8, 0x74u8, 0x61u8, 0x62u8, 0x6Cu8, 0x65u8, 0x20u8,
+        0x66u8, 0x6Fu8, 0x72u8, 0x00u8, 0x61u8, 0x6Cu8, 0x6Cu8, 0x20u8, 0x75u8, 0x73u8, 0x65u8,
+        0x72u8, 0x73u8, 0x2Fu8, 0x75u8, 0x73u8, 0x65u8, 0x73u8, 0x2Eu8, 0x20u8, 0x49u8, 0x74u8,
+        0x27u8, 0x73u8, 0x20u8, 0x61u8, 0x70u8, 0x70u8, 0x72u8, 0x6Fu8, 0x78u8, 0x69u8, 0x6Du8,
+        0x61u8, 0x74u8, 0x65u8, 0x20u8, 0x74u8, 0x69u8, 0x6Du8, 0x65u8, 0x20u8, 0x73u8, 0x70u8,
+        0x61u8, 0x6Eu8, 0x20u8, 0x69u8, 0x73u8, 0x20u8, 0x31u8, 0x35u8, 0x35u8, 0x30u8, 0x20u8,
+        0x4Au8, 0x41u8, 0x4Eu8, 0x20u8, 0x30u8, 0x31u8, 0x20u8, 0x74u8, 0x6Fu8, 0x20u8, 0x32u8,
+        0x36u8, 0x35u8, 0x30u8, 0x20u8, 0x4Au8, 0x41u8, 0x4Eu8, 0x20u8, 0x32u8, 0x32u8, 0x2Eu8,
+        0x00u8, 0x00u8, 0x49u8, 0x66u8, 0x20u8, 0x61u8, 0x20u8, 0x6Cu8, 0x6Fu8, 0x6Eu8, 0x67u8,
+        0x65u8, 0x72u8, 0x20u8, 0x74u8, 0x69u8, 0x6Du8, 0x65u8, 0x20u8, 0x73u8, 0x70u8, 0x61u8,
+        0x6Eu8, 0x20u8, 0x69u8, 0x73u8, 0x20u8, 0x6Eu8, 0x65u8, 0x65u8, 0x64u8, 0x65u8, 0x64u8,
+        0x2Cu8, 0x20u8, 0x44u8, 0x45u8, 0x34u8, 0x33u8, 0x31u8, 0x20u8, 0x6Du8, 0x61u8, 0x79u8,
+        0x20u8, 0x62u8, 0x65u8, 0x20u8, 0x75u8, 0x73u8, 0x65u8, 0x64u8, 0x2Cu8, 0x20u8, 0x65u8,
+        0x78u8, 0x63u8, 0x65u8, 0x70u8, 0x74u8, 0x20u8, 0x74u8, 0x68u8, 0x61u8, 0x74u8, 0x20u8,
+        0x74u8, 0x68u8, 0x65u8, 0x20u8, 0x6Cu8, 0x75u8, 0x6Eu8, 0x61u8, 0x72u8, 0x20u8, 0x65u8,
+        0x70u8, 0x68u8, 0x65u8, 0x6Du8, 0x65u8, 0x72u8, 0x69u8, 0x73u8, 0x00u8, 0x70u8, 0x6Fu8,
+        0x72u8, 0x74u8, 0x69u8, 0x6Fu8, 0x6Eu8, 0x20u8, 0x69u8, 0x73u8, 0x20u8, 0x6Fu8, 0x66u8,
+        0x20u8, 0x72u8, 0x65u8, 0x6Cu8, 0x61u8, 0x74u8, 0x69u8, 0x76u8, 0x65u8, 0x6Cu8, 0x79u8,
+        0x20u8, 0x70u8, 0x6Fu8, 0x6Fu8, 0x72u8, 0x20u8, 0x61u8, 0x63u8, 0x63u8, 0x75u8, 0x72u8,
+        0x61u8, 0x63u8, 0x79u8, 0x20u8, 0x6Fu8, 0x75u8, 0x74u8, 0x73u8, 0x69u8, 0x64u8, 0x65u8,
+        0x20u8, 0x6Fu8, 0x66u8, 0x20u8, 0x74u8, 0x68u8, 0x65u8, 0x20u8, 0x74u8, 0x69u8, 0x6Du8,
+        0x65u8, 0x20u8, 0x73u8, 0x70u8, 0x61u8, 0x6Eu8, 0x20u8, 0x63u8, 0x6Fu8, 0x76u8, 0x65u8,
+        0x72u8, 0x65u8, 0x64u8, 0x20u8, 0x62u8, 0x79u8, 0x20u8, 0x44u8, 0x45u8, 0x34u8, 0x33u8,
+        0x30u8, 0x2Eu8, 0x00u8, 0x54u8, 0x68u8, 0x65u8, 0x20u8, 0x74u8, 0x69u8, 0x6Du8, 0x65u8,
+        0x20u8, 0x73u8, 0x70u8, 0x61u8, 0x6Eu8, 0x20u8, 0x63u8, 0x6Fu8, 0x76u8, 0x65u8, 0x72u8,
+        0x65u8, 0x64u8, 0x20u8, 0x62u8, 0x79u8, 0x20u8, 0x44u8, 0x45u8, 0x34u8, 0x33u8, 0x31u8,
+        0x20u8, 0x69u8, 0x73u8, 0x20u8, 0x61u8, 0x70u8, 0x70u8, 0x72u8, 0x6Fu8, 0x78u8, 0x69u8,
+        0x6Du8, 0x61u8, 0x74u8, 0x65u8, 0x6Cu8, 0x79u8, 0x20u8, 0x31u8, 0x33u8, 0x32u8, 0x30u8,
+        0x32u8, 0x20u8, 0x42u8, 0x2Eu8, 0x43u8, 0x2Eu8, 0x20u8, 0x74u8, 0x6Fu8, 0x20u8, 0x31u8,
+        0x37u8, 0x31u8, 0x39u8, 0x31u8, 0x20u8, 0x41u8, 0x2Eu8, 0x44u8, 0x2Eu8, 0x20u8, 0x42u8,
+        0x65u8, 0x63u8, 0x61u8, 0x75u8, 0x73u8, 0x65u8, 0x20u8, 0x64u8, 0x65u8, 0x34u8, 0x33u8,
+        0x31u8, 0x00u8, 0x69u8, 0x73u8, 0x20u8, 0x73u8, 0x6Fu8, 0x20u8, 0x6Cu8, 0x6Fu8, 0x6Eu8,
+        0x67u8, 0x2Cu8, 0x20u8, 0x6Cu8, 0x65u8, 0x61u8, 0x64u8, 0x69u8, 0x6Eu8, 0x67u8, 0x20u8,
+        0x74u8, 0x6Fu8, 0x20u8, 0x61u8, 0x20u8, 0x68u8, 0x75u8, 0x67u8, 0x65u8, 0x20u8, 0x66u8,
+        0x69u8, 0x6Cu8, 0x65u8, 0x2Cu8, 0x20u8, 0x69u8, 0x74u8, 0x20u8, 0x68u8, 0x61u8, 0x73u8,
+        0x20u8, 0x62u8, 0x65u8, 0x65u8, 0x6Eu8, 0x20u8, 0x73u8, 0x70u8, 0x6Cu8, 0x69u8, 0x74u8,
+        0x20u8, 0x69u8, 0x6Eu8, 0x74u8, 0x6Fu8, 0x20u8, 0x74u8, 0x77u8, 0x6Fu8, 0x20u8, 0x70u8,
+        0x61u8, 0x72u8, 0x74u8, 0x73u8, 0x20u8, 0x68u8, 0x61u8, 0x76u8, 0x69u8, 0x6Eu8, 0x67u8,
+        0x20u8, 0x74u8, 0x68u8, 0x65u8, 0x00u8, 0x61u8, 0x70u8, 0x70u8, 0x72u8, 0x6Fu8, 0x78u8,
+        0x69u8, 0x6Du8, 0x61u8, 0x67u8, 0x74u8, 0x65u8, 0x20u8, 0x74u8, 0x69u8, 0x6Du8, 0x65u8,
+        0x20u8, 0x73u8, 0x70u8, 0x61u8, 0x6Eu8, 0x73u8, 0x20u8, 0x6Fu8, 0x66u8, 0x3Au8, 0x00u8,
+        0x00u8, 0x20u8, 0x20u8, 0x20u8, 0x31u8, 0x33u8, 0x32u8, 0x30u8, 0x32u8, 0x20u8, 0x42u8,
+        0x2Eu8, 0x43u8, 0x2Eu8, 0x20u8, 0x74u8, 0x6Fu8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x30u8, 0x00u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x30u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x74u8, 0x6Fu8, 0x20u8, 0x31u8, 0x37u8, 0x31u8,
+        0x39u8, 0x31u8, 0x20u8, 0x41u8, 0x2Eu8, 0x44u8, 0x2Eu8, 0x00u8, 0x00u8, 0x4Du8, 0x6Fu8,
+        0x72u8, 0x65u8, 0x20u8, 0x64u8, 0x65u8, 0x74u8, 0x61u8, 0x69u8, 0x6Cu8, 0x73u8, 0x20u8,
+        0x61u8, 0x62u8, 0x6Fu8, 0x75u8, 0x74u8, 0x20u8, 0x74u8, 0x68u8, 0x65u8, 0x73u8, 0x65u8,
+        0x20u8, 0x65u8, 0x70u8, 0x68u8, 0x65u8, 0x6Du8, 0x65u8, 0x72u8, 0x69u8, 0x73u8, 0x20u8,
+        0x66u8, 0x69u8, 0x6Cu8, 0x65u8, 0x73u8, 0x20u8, 0x61u8, 0x72u8, 0x65u8, 0x20u8, 0x63u8,
+        0x6Fu8, 0x6Eu8, 0x74u8, 0x61u8, 0x69u8, 0x6Eu8, 0x65u8, 0x64u8, 0x20u8, 0x69u8, 0x6Eu8,
+        0x20u8, 0x61u8, 0x63u8, 0x63u8, 0x6Fu8, 0x6Du8, 0x70u8, 0x61u8, 0x6Eu8, 0x79u8, 0x69u8,
+        0x6Eu8, 0x67u8, 0x20u8, 0x64u8, 0x6Fu8, 0x63u8, 0x75u8, 0x6Du8, 0x65u8, 0x6Eu8, 0x74u8,
+        0x61u8, 0x74u8, 0x69u8, 0x6Fu8, 0x6Eu8, 0x00u8, 0x61u8, 0x76u8, 0x61u8, 0x69u8, 0x6Cu8,
+        0x61u8, 0x62u8, 0x6Cu8, 0x65u8, 0x20u8, 0x6Fu8, 0x6Eu8, 0x20u8, 0x74u8, 0x68u8, 0x65u8,
+        0x20u8, 0x4Eu8, 0x41u8, 0x49u8, 0x46u8, 0x20u8, 0x73u8, 0x65u8, 0x72u8, 0x76u8, 0x65u8,
+        0x72u8, 0x3Au8, 0x20u8, 0x20u8, 0x68u8, 0x74u8, 0x74u8, 0x70u8, 0x3Au8, 0x2Fu8, 0x2Fu8,
+        0x6Eu8, 0x61u8, 0x69u8, 0x66u8, 0x2Eu8, 0x6Au8, 0x70u8, 0x6Cu8, 0x2Eu8, 0x6Eu8, 0x61u8,
+        0x73u8, 0x61u8, 0x2Eu8, 0x67u8, 0x6Fu8, 0x76u8, 0x2Fu8, 0x70u8, 0x75u8, 0x62u8, 0x2Fu8,
+        0x6Eu8, 0x61u8, 0x69u8, 0x66u8, 0x2Fu8, 0x67u8, 0x65u8, 0x6Eu8, 0x65u8, 0x72u8, 0x69u8,
+        0x63u8, 0x5Fu8, 0x6Bu8, 0x65u8, 0x72u8, 0x6Eu8, 0x65u8, 0x6Cu8, 0x73u8, 0x2Fu8, 0x73u8,
+        0x70u8, 0x6Bu8, 0x2Fu8, 0x70u8, 0x6Cu8, 0x61u8, 0x6Eu8, 0x65u8, 0x74u8, 0x73u8, 0x2Fu8,
+        0x00u8, 0x00u8, 0x00u8, 0x53u8, 0x70u8, 0x65u8, 0x63u8, 0x69u8, 0x61u8, 0x6Cu8, 0x20u8,
+        0x6Eu8, 0x6Fu8, 0x74u8, 0x65u8, 0x20u8, 0x72u8, 0x65u8, 0x67u8, 0x61u8, 0x72u8, 0x64u8,
+        0x69u8, 0x6Eu8, 0x67u8, 0x20u8, 0x4Du8, 0x61u8, 0x72u8, 0x73u8, 0x3Au8, 0x20u8, 0x20u8,
+        0x73u8, 0x74u8, 0x61u8, 0x72u8, 0x74u8, 0x69u8, 0x6Eu8, 0x67u8, 0x20u8, 0x77u8, 0x69u8,
+        0x74u8, 0x68u8, 0x20u8, 0x74u8, 0x68u8, 0x69u8, 0x73u8, 0x20u8, 0x44u8, 0x45u8, 0x20u8,
+        0x66u8, 0x69u8, 0x6Cu8, 0x65u8, 0x20u8, 0x74u8, 0x68u8, 0x65u8, 0x20u8, 0x6Cu8, 0x6Fu8,
+        0x63u8, 0x61u8, 0x74u8, 0x69u8, 0x6Fu8, 0x6Eu8, 0x20u8, 0x6Fu8, 0x66u8, 0x20u8, 0x4Du8,
+        0x61u8, 0x72u8, 0x73u8, 0x27u8, 0x20u8, 0x6Du8, 0x61u8, 0x73u8, 0x73u8, 0x20u8, 0x63u8,
+        0x65u8, 0x6Eu8, 0x74u8, 0x65u8, 0x72u8, 0x00u8, 0x28u8, 0x4Eu8, 0x41u8, 0x49u8, 0x46u8,
+        0x20u8, 0x49u8, 0x44u8, 0x20u8, 0x3Du8, 0x20u8, 0x34u8, 0x39u8, 0x39u8, 0x29u8, 0x20u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x69u8, 0x73u8, 0x20u8, 0x2Au8, 0x4Eu8, 0x4Fu8, 0x54u8, 0x2Au8, 0x20u8,
+        0x69u8, 0x6Eu8, 0x63u8, 0x6Cu8, 0x75u8, 0x64u8, 0x65u8, 0x64u8, 0x3Bu8, 0x20u8, 0x6Fu8,
+        0x6Eu8, 0x6Cu8, 0x79u8, 0x20u8, 0x74u8, 0x68u8, 0x65u8, 0x20u8, 0x4Du8, 0x61u8, 0x72u8,
+        0x73u8, 0x20u8, 0x73u8, 0x79u8, 0x73u8, 0x74u8, 0x65u8, 0x6Du8, 0x20u8, 0x62u8, 0x61u8,
+        0x72u8, 0x79u8, 0x63u8, 0x65u8, 0x6Eu8, 0x74u8, 0x65u8, 0x72u8, 0x20u8, 0x28u8, 0x49u8,
+        0x44u8, 0x20u8, 0x3Du8, 0x20u8, 0x34u8, 0x29u8, 0x20u8, 0x69u8, 0x73u8, 0x20u8, 0x70u8,
+        0x72u8, 0x65u8, 0x73u8, 0x65u8, 0x6Eu8, 0x74u8, 0x2Eu8, 0x00u8, 0x54u8, 0x68u8, 0x65u8,
+        0x20u8, 0x6Fu8, 0x66u8, 0x66u8, 0x73u8, 0x65u8, 0x74u8, 0x20u8, 0x62u8, 0x65u8, 0x74u8,
+        0x77u8, 0x65u8, 0x65u8, 0x6Eu8, 0x20u8, 0x4Du8, 0x61u8, 0x72u8, 0x73u8, 0x27u8, 0x20u8,
+        0x6Du8, 0x61u8, 0x73u8, 0x73u8, 0x20u8, 0x63u8, 0x65u8, 0x6Eu8, 0x74u8, 0x65u8, 0x72u8,
+        0x20u8, 0x61u8, 0x6Eu8, 0x64u8, 0x20u8, 0x74u8, 0x68u8, 0x65u8, 0x20u8, 0x4Du8, 0x61u8,
+        0x72u8, 0x73u8, 0x27u8, 0x20u8, 0x73u8, 0x79u8, 0x73u8, 0x74u8, 0x65u8, 0x6Du8, 0x20u8,
+        0x62u8, 0x61u8, 0x72u8, 0x79u8, 0x63u8, 0x65u8, 0x6Eu8, 0x74u8, 0x65u8, 0x72u8, 0x20u8,
+        0x69u8, 0x6Eu8, 0x20u8, 0x44u8, 0x45u8, 0x34u8, 0x30u8, 0x33u8, 0x20u8, 0x69u8, 0x73u8,
+        0x20u8, 0x71u8, 0x75u8, 0x69u8, 0x74u8, 0x65u8, 0x20u8, 0x73u8, 0x6Du8, 0x61u8, 0x6Cu8,
+        0x6Cu8, 0x00u8, 0x2Du8, 0x2Du8, 0x61u8, 0x62u8, 0x6Fu8, 0x75u8, 0x74u8, 0x20u8, 0x32u8,
+        0x30u8, 0x20u8, 0x63u8, 0x6Du8, 0x2Eu8, 0x2Du8, 0x2Du8, 0x73u8, 0x6Fu8, 0x20u8, 0x6Du8,
+        0x6Fu8, 0x73u8, 0x74u8, 0x20u8, 0x53u8, 0x50u8, 0x49u8, 0x43u8, 0x45u8, 0x20u8, 0x75u8,
+        0x73u8, 0x65u8, 0x72u8, 0x73u8, 0x20u8, 0x63u8, 0x6Fu8, 0x75u8, 0x6Cu8, 0x64u8, 0x20u8,
+        0x75u8, 0x73u8, 0x65u8, 0x20u8, 0x74u8, 0x68u8, 0x65u8, 0x20u8, 0x4Du8, 0x61u8, 0x72u8,
+        0x73u8, 0x20u8, 0x73u8, 0x79u8, 0x73u8, 0x74u8, 0x65u8, 0x6Du8, 0x20u8, 0x62u8, 0x61u8,
+        0x72u8, 0x79u8, 0x63u8, 0x65u8, 0x6Eu8, 0x74u8, 0x65u8, 0x72u8, 0x20u8, 0x69u8, 0x6Eu8,
+        0x20u8, 0x70u8, 0x6Cu8, 0x61u8, 0x63u8, 0x65u8, 0x20u8, 0x6Fu8, 0x66u8, 0x20u8, 0x74u8,
+        0x68u8, 0x65u8, 0x00u8, 0x4Du8, 0x61u8, 0x72u8, 0x73u8, 0x20u8, 0x6Du8, 0x61u8, 0x73u8,
+        0x73u8, 0x20u8, 0x63u8, 0x65u8, 0x6Eu8, 0x74u8, 0x65u8, 0x72u8, 0x2Eu8, 0x20u8, 0x48u8,
+        0x6Fu8, 0x77u8, 0x65u8, 0x76u8, 0x65u8, 0x72u8, 0x2Cu8, 0x20u8, 0x69u8, 0x66u8, 0x20u8,
+        0x79u8, 0x6Fu8, 0x75u8, 0x20u8, 0x77u8, 0x69u8, 0x73u8, 0x68u8, 0x2Fu8, 0x6Eu8, 0x65u8,
+        0x65u8, 0x64u8, 0x20u8, 0x74u8, 0x6Fu8, 0x20u8, 0x68u8, 0x61u8, 0x76u8, 0x65u8, 0x20u8,
+        0x74u8, 0x68u8, 0x65u8, 0x20u8, 0x4Du8, 0x61u8, 0x72u8, 0x73u8, 0x20u8, 0x6Du8, 0x61u8,
+        0x73u8, 0x73u8, 0x20u8, 0x63u8, 0x65u8, 0x6Eu8, 0x74u8, 0x65u8, 0x72u8, 0x20u8, 0x61u8,
+        0x76u8, 0x61u8, 0x69u8, 0x6Cu8, 0x61u8, 0x62u8, 0x6Cu8, 0x65u8, 0x20u8, 0x74u8, 0x6Fu8,
+        0x20u8, 0x79u8, 0x6Fu8, 0x75u8, 0x72u8, 0x00u8, 0x70u8, 0x72u8, 0x6Fu8, 0x67u8, 0x72u8,
+        0x61u8, 0x6Du8, 0x2Cu8, 0x20u8, 0x79u8, 0x6Fu8, 0x75u8, 0x27u8, 0x6Cu8, 0x6Cu8, 0x20u8,
+        0x6Eu8, 0x65u8, 0x65u8, 0x64u8, 0x20u8, 0x74u8, 0x6Fu8, 0x20u8, 0x6Cu8, 0x6Fu8, 0x61u8,
+        0x64u8, 0x20u8, 0x61u8, 0x20u8, 0x4Du8, 0x61u8, 0x72u8, 0x73u8, 0x20u8, 0x73u8, 0x61u8,
+        0x74u8, 0x65u8, 0x6Cu8, 0x6Cu8, 0x69u8, 0x74u8, 0x65u8, 0x20u8, 0x65u8, 0x70u8, 0x68u8,
+        0x65u8, 0x6Du8, 0x65u8, 0x72u8, 0x69u8, 0x73u8, 0x20u8, 0x66u8, 0x69u8, 0x6Cu8, 0x65u8,
+        0x20u8, 0x73u8, 0x75u8, 0x63u8, 0x68u8, 0x20u8, 0x61u8, 0x73u8, 0x20u8, 0x22u8, 0x6Du8,
+        0x61u8, 0x72u8, 0x30u8, 0x39u8, 0x37u8, 0x2Eu8, 0x62u8, 0x73u8, 0x70u8, 0x22u8, 0x20u8,
+        0x69u8, 0x6Eu8, 0x20u8, 0x61u8, 0x64u8, 0x64u8, 0x69u8, 0x74u8, 0x69u8, 0x6Fu8, 0x6Eu8,
+        0x00u8, 0x74u8, 0x6Fu8, 0x20u8, 0x44u8, 0x45u8, 0x34u8, 0x33u8, 0x30u8, 0x2Eu8, 0x20u8,
+        0x53u8, 0x61u8, 0x74u8, 0x65u8, 0x6Cu8, 0x6Cu8, 0x69u8, 0x74u8, 0x65u8, 0x20u8, 0x65u8,
+        0x70u8, 0x68u8, 0x65u8, 0x6Du8, 0x65u8, 0x72u8, 0x69u8, 0x73u8, 0x20u8, 0x66u8, 0x69u8,
+        0x6Cu8, 0x65u8, 0x73u8, 0x20u8, 0x61u8, 0x72u8, 0x65u8, 0x20u8, 0x61u8, 0x76u8, 0x61u8,
+        0x69u8, 0x6Cu8, 0x61u8, 0x62u8, 0x6Cu8, 0x65u8, 0x20u8, 0x66u8, 0x72u8, 0x6Fu8, 0x6Du8,
+        0x20u8, 0x74u8, 0x68u8, 0x65u8, 0x20u8, 0x4Eu8, 0x41u8, 0x49u8, 0x46u8, 0x20u8, 0x73u8,
+        0x65u8, 0x72u8, 0x76u8, 0x65u8, 0x72u8, 0x20u8, 0x68u8, 0x65u8, 0x72u8, 0x65u8, 0x3Au8,
+        0x00u8, 0x68u8, 0x74u8, 0x74u8, 0x70u8, 0x3Au8, 0x2Fu8, 0x2Fu8, 0x6Eu8, 0x61u8, 0x69u8,
+        0x66u8, 0x2Eu8, 0x6Au8, 0x70u8, 0x6Cu8, 0x2Eu8, 0x6Eu8, 0x61u8, 0x73u8, 0x61u8, 0x2Eu8,
+        0x67u8, 0x6Fu8, 0x76u8, 0x2Fu8, 0x70u8, 0x75u8, 0x62u8, 0x2Fu8, 0x6Eu8, 0x61u8, 0x69u8,
+        0x66u8, 0x2Fu8, 0x67u8, 0x65u8, 0x6Eu8, 0x65u8, 0x72u8, 0x69u8, 0x63u8, 0x5Fu8, 0x6Bu8,
+        0x65u8, 0x72u8, 0x6Eu8, 0x65u8, 0x6Cu8, 0x73u8, 0x2Fu8, 0x73u8, 0x70u8, 0x6Bu8, 0x2Fu8,
+        0x73u8, 0x61u8, 0x74u8, 0x65u8, 0x6Cu8, 0x6Cu8, 0x69u8, 0x74u8, 0x65u8, 0x73u8, 0x2Fu8,
+        0x00u8, 0x00u8, 0x00u8, 0x44u8, 0x65u8, 0x74u8, 0x61u8, 0x69u8, 0x6Cu8, 0x73u8, 0x20u8,
+        0x61u8, 0x62u8, 0x6Fu8, 0x75u8, 0x74u8, 0x20u8, 0x53u8, 0x50u8, 0x49u8, 0x43u8, 0x45u8,
+        0x20u8, 0x70u8, 0x6Cu8, 0x61u8, 0x6Eu8, 0x65u8, 0x74u8, 0x20u8, 0x61u8, 0x6Eu8, 0x64u8,
+        0x20u8, 0x73u8, 0x61u8, 0x74u8, 0x65u8, 0x6Cu8, 0x6Cu8, 0x69u8, 0x74u8, 0x65u8, 0x20u8,
+        0x65u8, 0x70u8, 0x68u8, 0x65u8, 0x6Du8, 0x65u8, 0x72u8, 0x69u8, 0x73u8, 0x20u8, 0x66u8,
+        0x69u8, 0x6Cu8, 0x65u8, 0x73u8, 0x2Cu8, 0x20u8, 0x6Bu8, 0x6Eu8, 0x6Fu8, 0x77u8, 0x6Eu8,
+        0x20u8, 0x61u8, 0x73u8, 0x20u8, 0x53u8, 0x50u8, 0x4Bu8, 0x20u8, 0x66u8, 0x69u8, 0x6Cu8,
+        0x65u8, 0x73u8, 0x2Cu8, 0x20u8, 0x69u8, 0x6Eu8, 0x63u8, 0x6Cu8, 0x75u8, 0x64u8, 0x69u8,
+        0x6Eu8, 0x67u8, 0x00u8, 0x68u8, 0x6Fu8, 0x77u8, 0x20u8, 0x74u8, 0x6Fu8, 0x20u8, 0x72u8,
+        0x65u8, 0x61u8, 0x64u8, 0x20u8, 0x74u8, 0x68u8, 0x65u8, 0x6Du8, 0x20u8, 0x75u8, 0x73u8,
+        0x69u8, 0x6Eu8, 0x67u8, 0x20u8, 0x53u8, 0x50u8, 0x49u8, 0x43u8, 0x45u8, 0x20u8, 0x54u8,
+        0x6Fu8, 0x6Fu8, 0x6Cu8, 0x6Bu8, 0x69u8, 0x74u8, 0x20u8, 0x73u8, 0x6Fu8, 0x66u8, 0x74u8,
+        0x77u8, 0x61u8, 0x72u8, 0x65u8, 0x2Cu8, 0x20u8, 0x6Du8, 0x61u8, 0x79u8, 0x20u8, 0x62u8,
+        0x65u8, 0x20u8, 0x66u8, 0x6Fu8, 0x75u8, 0x6Eu8, 0x64u8, 0x20u8, 0x69u8, 0x6Eu8, 0x20u8,
+        0x74u8, 0x68u8, 0x65u8, 0x20u8, 0x53u8, 0x50u8, 0x4Bu8, 0x20u8, 0x74u8, 0x75u8, 0x74u8,
+        0x6Fu8, 0x72u8, 0x69u8, 0x61u8, 0x6Cu8, 0x20u8, 0x28u8, 0x50u8, 0x44u8, 0x46u8, 0x20u8,
+        0x66u8, 0x69u8, 0x6Cu8, 0x65u8, 0x00u8, 0x6Eu8, 0x61u8, 0x6Du8, 0x65u8, 0x20u8, 0x69u8,
+        0x73u8, 0x20u8, 0x22u8, 0x31u8, 0x39u8, 0x5Fu8, 0x73u8, 0x70u8, 0x6Bu8, 0x22u8, 0x29u8,
+        0x20u8, 0x61u8, 0x76u8, 0x61u8, 0x69u8, 0x6Cu8, 0x61u8, 0x62u8, 0x6Cu8, 0x65u8, 0x20u8,
+        0x66u8, 0x72u8, 0x6Fu8, 0x6Du8, 0x20u8, 0x74u8, 0x68u8, 0x65u8, 0x20u8, 0x4Eu8, 0x41u8,
+        0x49u8, 0x46u8, 0x20u8, 0x77u8, 0x65u8, 0x62u8, 0x73u8, 0x69u8, 0x74u8, 0x65u8, 0x20u8,
+        0x28u8, 0x68u8, 0x74u8, 0x74u8, 0x70u8, 0x3Au8, 0x2Fu8, 0x2Fu8, 0x6Eu8, 0x61u8, 0x69u8,
+        0x66u8, 0x2Eu8, 0x6Au8, 0x70u8, 0x6Cu8, 0x2Eu8, 0x6Eu8, 0x61u8, 0x73u8, 0x61u8, 0x2Eu8,
+        0x67u8, 0x6Fu8, 0x76u8, 0x2Fu8, 0x74u8, 0x75u8, 0x74u8, 0x6Fu8, 0x72u8, 0x69u8, 0x61u8,
+        0x6Cu8, 0x73u8, 0x2Eu8, 0x68u8, 0x74u8, 0x6Du8, 0x6Cu8, 0x29u8, 0x2Eu8, 0x00u8, 0x00u8,
+        0x00u8, 0x04u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0xF0u8, 0x3Fu8, 0x00u8, 0x00u8, 0x00u8, 0xA6u8, 0x71u8, 0x73u8,
+        0x0Au8, 0xC2u8, 0x00u8, 0x00u8, 0x00u8, 0x2Du8, 0xF0u8, 0x1Au8, 0x13u8, 0x42u8, 0x01u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x01u8, 0x00u8, 0x00u8, 0x00u8,
+        0x02u8, 0x00u8, 0x00u8, 0x00u8, 0x81u8, 0x02u8, 0x00u8, 0x00u8, 0x00u8, 0x05u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0xA6u8, 0x71u8, 0x73u8, 0x0Au8, 0xC2u8, 0x00u8, 0x00u8,
+        0x00u8, 0x2Du8, 0xF0u8, 0x1Au8, 0x13u8, 0x42u8, 0x02u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x01u8, 0x00u8, 0x00u8, 0x00u8, 0x02u8, 0x00u8, 0x00u8, 0x00u8,
+        0xC5u8, 0xBAu8, 0x21u8, 0x00u8, 0xC8u8, 0xFDu8, 0x2Du8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0xA6u8, 0x71u8, 0x73u8, 0x0Au8, 0xC2u8, 0x00u8, 0x00u8, 0x00u8, 0x2Du8, 0xF0u8, 0x1Au8,
+        0x13u8, 0x42u8, 0x03u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x01u8,
+        0x00u8, 0x00u8, 0x00u8, 0x02u8, 0x00u8, 0x00u8, 0x00u8, 0xC9u8, 0xFDu8, 0x2Du8, 0x00u8,
+        0xA4u8, 0xB3u8, 0x3Du8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0xA6u8, 0x71u8, 0x73u8, 0x0Au8,
+        0xC2u8, 0x00u8, 0x00u8, 0x00u8, 0x2Du8, 0xF0u8, 0x1Au8, 0x13u8, 0x42u8, 0x04u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x01u8, 0x00u8, 0x00u8, 0x00u8, 0x02u8,
+        0x00u8, 0x00u8, 0x00u8, 0xA5u8, 0xB3u8, 0x3Du8, 0x00u8, 0x4Cu8, 0x68u8, 0x44u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0xA6u8, 0x71u8, 0x73u8, 0x0Au8, 0xC2u8, 0x00u8, 0x00u8, 0x00u8,
+        0x2Du8, 0xF0u8, 0x1Au8, 0x13u8, 0x42u8, 0x05u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x01u8, 0x00u8, 0x00u8, 0x00u8, 0x02u8, 0x00u8, 0x00u8, 0x00u8, 0x4Du8,
+        0x68u8, 0x44u8, 0x00u8, 0x88u8, 0x63u8, 0x49u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0xA6u8,
+        0x71u8, 0x73u8, 0x0Au8, 0xC2u8, 0x00u8, 0x00u8, 0x00u8, 0x2Du8, 0xF0u8, 0x1Au8, 0x13u8,
+        0x42u8, 0x06u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x01u8, 0x00u8,
+        0x00u8, 0x00u8, 0x02u8, 0x00u8, 0x00u8, 0x00u8, 0x89u8, 0x63u8, 0x49u8, 0x00u8, 0xA0u8,
+        0xCBu8, 0x4Du8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0xA6u8, 0x71u8, 0x73u8, 0x0Au8, 0xC2u8,
+        0x00u8, 0x00u8, 0x00u8, 0x2Du8, 0xF0u8, 0x1Au8, 0x13u8, 0x42u8, 0x07u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x01u8, 0x00u8, 0x00u8, 0x00u8, 0x02u8, 0x00u8,
+        0x00u8, 0x00u8, 0xA1u8, 0xCBu8, 0x4Du8, 0x00u8, 0x94u8, 0xA0u8, 0x51u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0xA6u8, 0x71u8, 0x73u8, 0x0Au8, 0xC2u8, 0x00u8, 0x00u8, 0x00u8, 0x2Du8,
+        0xF0u8, 0x1Au8, 0x13u8, 0x42u8, 0x08u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x01u8, 0x00u8, 0x00u8, 0x00u8, 0x02u8, 0x00u8, 0x00u8, 0x00u8, 0x95u8, 0xA0u8,
+        0x51u8, 0x00u8, 0x88u8, 0x75u8, 0x55u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0xA6u8, 0x71u8,
+        0x73u8, 0x0Au8, 0xC2u8, 0x00u8, 0x00u8, 0x00u8, 0x2Du8, 0xF0u8, 0x1Au8, 0x13u8, 0x42u8,
+        0x09u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x01u8, 0x00u8, 0x00u8,
+        0x00u8, 0x02u8, 0x00u8, 0x00u8, 0x00u8, 0x89u8, 0x75u8, 0x55u8, 0x00u8, 0x7Cu8, 0x4Au8,
+        0x59u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0xA6u8, 0x71u8, 0x73u8, 0x0Au8, 0xC2u8, 0x00u8,
+        0x00u8, 0x00u8, 0x2Du8, 0xF0u8, 0x1Au8, 0x13u8, 0x42u8, 0x0Au8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x01u8, 0x00u8, 0x00u8, 0x00u8, 0x02u8, 0x00u8, 0x00u8,
+        0x00u8, 0x7Du8, 0x4Au8, 0x59u8, 0x00u8, 0xC8u8, 0xB3u8, 0x66u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0xA6u8, 0x71u8, 0x73u8, 0x0Au8, 0xC2u8, 0x00u8, 0x00u8, 0x00u8, 0x2Du8, 0xF0u8,
+        0x1Au8, 0x13u8, 0x42u8, 0x2Du8, 0x01u8, 0x00u8, 0x00u8, 0x03u8, 0x00u8, 0x00u8, 0x00u8,
+        0x01u8, 0x00u8, 0x00u8, 0x00u8, 0x02u8, 0x00u8, 0x00u8, 0x00u8, 0xC9u8, 0xB3u8, 0x66u8,
+        0x00u8, 0x2Cu8, 0x8Bu8, 0xA5u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0xA6u8, 0x71u8, 0x73u8,
+        0x0Au8, 0xC2u8, 0x00u8, 0x00u8, 0x00u8, 0x2Du8, 0xF0u8, 0x1Au8, 0x13u8, 0x42u8, 0x8Fu8,
+        0x01u8, 0x00u8, 0x00u8, 0x03u8, 0x00u8, 0x00u8, 0x00u8, 0x01u8, 0x00u8, 0x00u8, 0x00u8,
+        0x02u8, 0x00u8, 0x00u8, 0x00u8, 0x2Du8, 0x8Bu8, 0xA5u8, 0x00u8, 0x90u8, 0x62u8, 0xE4u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0xA6u8, 0x71u8, 0x73u8, 0x0Au8, 0xC2u8, 0x00u8, 0x00u8,
+        0x00u8, 0x2Du8, 0xF0u8, 0x1Au8, 0x13u8, 0x42u8, 0xC7u8, 0x00u8, 0x00u8, 0x00u8, 0x01u8,
+        0x00u8, 0x00u8, 0x00u8, 0x01u8, 0x00u8, 0x00u8, 0x00u8, 0x02u8, 0x00u8, 0x00u8, 0x00u8,
+        0x91u8, 0x62u8, 0xE4u8, 0x00u8, 0x9Cu8, 0x62u8, 0xE4u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0xA6u8, 0x71u8, 0x73u8, 0x0Au8, 0xC2u8, 0x00u8, 0x00u8, 0x00u8, 0x2Du8, 0xF0u8, 0x1Au8,
+        0x13u8, 0x42u8, 0x2Bu8, 0x01u8, 0x00u8, 0x00u8, 0x02u8, 0x00u8, 0x00u8, 0x00u8, 0x01u8,
+        0x00u8, 0x00u8, 0x00u8, 0x02u8, 0x00u8, 0x00u8, 0x00u8, 0x9Du8, 0x62u8, 0xE4u8, 0x00u8,
+        0xA8u8, 0x62u8, 0xE4u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x44u8, 0x45u8, 0x2Du8, 0x30u8, 0x34u8, 0x33u8, 0x30u8,
+        0x4Cu8, 0x45u8, 0x2Du8, 0x30u8, 0x34u8, 0x33u8, 0x30u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x44u8, 0x45u8, 0x2Du8, 0x30u8, 0x34u8, 0x33u8, 0x30u8, 0x4Cu8, 0x45u8, 0x2Du8, 0x30u8,
+        0x34u8, 0x33u8, 0x30u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x44u8, 0x45u8, 0x2Du8, 0x30u8,
+        0x34u8, 0x33u8, 0x30u8, 0x4Cu8, 0x45u8, 0x2Du8, 0x30u8, 0x34u8, 0x33u8, 0x30u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x44u8, 0x45u8, 0x2Du8, 0x30u8, 0x34u8, 0x33u8, 0x30u8, 0x4Cu8,
+        0x45u8, 0x2Du8, 0x30u8, 0x34u8, 0x33u8, 0x30u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x44u8,
+        0x45u8, 0x2Du8, 0x30u8, 0x34u8, 0x33u8, 0x30u8, 0x4Cu8, 0x45u8, 0x2Du8, 0x30u8, 0x34u8,
+        0x33u8, 0x30u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x44u8, 0x45u8, 0x2Du8, 0x30u8, 0x34u8,
+        0x33u8, 0x30u8, 0x4Cu8, 0x45u8, 0x2Du8, 0x30u8, 0x34u8, 0x33u8, 0x30u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x44u8, 0x45u8, 0x2Du8, 0x30u8, 0x34u8, 0x33u8, 0x30u8, 0x4Cu8, 0x45u8,
+        0x2Du8, 0x30u8, 0x34u8, 0x33u8, 0x30u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x44u8, 0x45u8,
+        0x2Du8, 0x30u8, 0x34u8, 0x33u8, 0x30u8, 0x4Cu8, 0x45u8, 0x2Du8, 0x30u8, 0x34u8, 0x33u8,
+        0x30u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x44u8, 0x45u8, 0x2Du8, 0x30u8, 0x34u8, 0x33u8,
+        0x30u8, 0x4Cu8, 0x45u8, 0x2Du8, 0x30u8, 0x34u8, 0x33u8, 0x30u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x44u8, 0x45u8, 0x2Du8, 0x30u8, 0x34u8, 0x33u8, 0x30u8, 0x4Cu8, 0x45u8, 0x2Du8,
+        0x30u8, 0x34u8, 0x33u8, 0x30u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x44u8, 0x45u8, 0x2Du8,
+        0x30u8, 0x34u8, 0x33u8, 0x30u8, 0x4Cu8, 0x45u8, 0x2Du8, 0x30u8, 0x34u8, 0x33u8, 0x30u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x44u8, 0x45u8, 0x2Du8, 0x30u8, 0x34u8, 0x33u8, 0x30u8,
+        0x4Cu8, 0x45u8, 0x2Du8, 0x30u8, 0x34u8, 0x33u8, 0x30u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x44u8, 0x45u8, 0x2Du8, 0x30u8, 0x34u8, 0x33u8, 0x30u8, 0x4Cu8, 0x45u8, 0x2Du8, 0x30u8,
+        0x34u8, 0x33u8, 0x30u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x44u8, 0x45u8, 0x2Du8, 0x30u8,
+        0x34u8, 0x33u8, 0x30u8, 0x4Cu8, 0x45u8, 0x2Du8, 0x30u8, 0x34u8, 0x33u8, 0x30u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8, 0x20u8,
+        0x20u8, 0x20u8, 0x20u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x76u8, 0x47u8, 0x73u8,
+        0x0Au8, 0xC2u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x18u8, 0x15u8, 0x41u8, 0xBCu8,
+        0xF5u8, 0x9Du8, 0xF2u8, 0x5Fu8, 0x9Eu8, 0x85u8, 0xC1u8, 0x19u8, 0xF1u8, 0x4Fu8, 0x16u8,
+        0xA2u8, 0xC8u8, 0x65u8, 0xC1u8, 0x3Eu8, 0x36u8, 0x70u8, 0xD5u8, 0x18u8, 0xCBu8, 0x32u8,
+        0x41u8, 0x85u8, 0xBAu8, 0x34u8, 0xE3u8, 0x57u8, 0x51u8, 0xCAu8, 0x40u8, 0x2Cu8, 0xDEu8,
+        0xF9u8, 0xE2u8, 0x7Cu8, 0xA4u8, 0xB1u8, 0xC0u8, 0xE8u8, 0x91u8, 0x76u8, 0x05u8, 0xB0u8,
+        0xFDu8, 0x6Fu8, 0x40u8, 0xEFu8, 0x8Cu8, 0x69u8, 0x39u8, 0xBCu8, 0xEDu8, 0xE5u8, 0xBFu8,
+        0x48u8, 0x22u8, 0xBFu8, 0x37u8, 0x0Au8, 0xFBu8, 0xF2u8, 0xBFu8, 0xBCu8, 0xC0u8, 0xE0u8,
+        0x57u8, 0xEDu8, 0x84u8, 0xBAu8, 0x3Fu8, 0x08u8, 0x5Bu8, 0xE3u8, 0x7Cu8, 0x9Cu8, 0x07u8,
+        0x64u8, 0xBFu8, 0x1Du8, 0x6Au8, 0x77u8, 0xE1u8, 0xCBu8, 0xE4u8, 0x38u8, 0xBFu8, 0x55u8,
+        0xCDu8, 0x99u8, 0x83u8, 0x32u8, 0x83u8, 0x09u8, 0x3Fu8, 0x4Cu8, 0x0Eu8, 0x8Eu8, 0x41u8,
+        0xD6u8, 0x90u8, 0xC1u8, 0xBEu8, 0x8Eu8, 0xABu8, 0x3Eu8, 0x15u8, 0x3Fu8, 0xDFu8, 0x7Du8,
+        0xBEu8, 0x41u8, 0x1Fu8, 0x25u8, 0x27u8, 0xFDu8, 0x78u8, 0x72u8, 0x41u8, 0xA4u8, 0xEAu8,
+        0x80u8, 0xC3u8, 0xE3u8, 0x1Au8, 0x68u8, 0xC1u8, 0x58u8, 0xB7u8, 0xDEu8, 0x3Au8, 0xD6u8,
+        0x1Au8, 0x21u8, 0xC1u8, 0xFDu8, 0xE2u8, 0x11u8, 0x6Du8, 0x54u8, 0x60u8, 0xF2u8, 0x40u8,
+        0xF2u8, 0x08u8, 0x47u8, 0x2Eu8, 0xA3u8, 0xC8u8, 0x9Bu8, 0xC0u8, 0xC8u8, 0xFCu8, 0x7Bu8,
+        0xA1u8, 0x8Bu8, 0x63u8, 0x61u8, 0xC0u8, 0x1Bu8, 0x40u8, 0x34u8, 0x6Fu8, 0xE3u8, 0x96u8,
+        0x32u8, 0x40u8, 0x72u8, 0xAAu8, 0x1Du8, 0xF3u8, 0x3Cu8, 0x1Bu8, 0xEBu8, 0xBFu8, 0x5Cu8,
+        0x6Au8, 0xF8u8, 0xC4u8, 0x59u8, 0xBDu8, 0x99u8, 0xBFu8, 0x50u8, 0xC6u8, 0x60u8, 0xF1u8,
+        0xC1u8, 0xFCu8, 0x7Bu8, 0x3Fu8, 0x1Du8, 0xF9u8, 0x72u8, 0x29u8, 0xA4u8, 0x15u8, 0x3Eu8,
+        0xBFu8, 0x25u8, 0xA1u8, 0x4Bu8, 0xEFu8, 0xFFu8, 0xD7u8, 0xA1u8, 0x3Eu8, 0xFCu8, 0x05u8,
+        0xE8u8, 0x73u8, 0xF7u8, 0x2Eu8, 0xC7u8, 0x3Eu8, 0x03u8, 0xFBu8, 0x6Eu8, 0xE1u8, 0x8Eu8,
+        0x50u8, 0x91u8, 0xBEu8, 0x8Cu8, 0x4Fu8, 0x14u8, 0x91u8, 0x00u8, 0xC6u8, 0x6Cu8, 0x41u8,
+        0xFCu8, 0xF8u8, 0x98u8, 0xBDu8, 0x9Bu8, 0x23u8, 0x55u8, 0xC1u8, 0xE5u8, 0x4Au8, 0xF2u8,
+        0x3Du8, 0xE3u8, 0x23u8, 0x1Au8, 0xC1u8, 0x86u8, 0xCFu8, 0xA8u8, 0x6Du8, 0xC5u8, 0xE9u8,
+        0xE2u8, 0x40u8, 0xC0u8, 0xE3u8, 0x7Du8, 0xFDu8, 0x7Eu8, 0xA4u8, 0x7Du8, 0xC0u8, 0x04u8,
+        0xFAu8, 0x72u8, 0xCEu8, 0xA5u8, 0x44u8, 0x59u8, 0xC0u8, 0xCEu8, 0x6Eu8, 0xA8u8, 0xBAu8,
+        0xA7u8, 0xF9u8, 0x23u8, 0x40u8, 0x16u8, 0xACu8, 0x13u8, 0xE5u8, 0x2Fu8, 0xF2u8, 0xD4u8,
+        0xBFu8, 0x7Du8, 0xC1u8, 0x9Bu8, 0x2Fu8, 0xECu8, 0xDDu8, 0x98u8, 0xBFu8, 0x96u8, 0x34u8,
+        0xCDu8, 0x5Eu8, 0xC7u8, 0xF5u8, 0x6Fu8, 0x3Fu8, 0x72u8, 0x46u8, 0x74u8, 0xACu8, 0xFAu8,
+        0xDDu8, 0x2Au8, 0xBFu8, 0x72u8, 0xF4u8, 0xF6u8, 0x3Eu8, 0x31u8, 0x3Du8, 0xD4u8, 0xBEu8,
+        0x6Eu8, 0xE9u8, 0x5Eu8, 0xF2u8, 0x73u8, 0x6Bu8, 0xBCu8, 0x3Eu8, 0x1Bu8, 0xBAu8, 0xABu8,
+        0xD0u8, 0x60u8, 0xE3u8, 0x80u8, 0xBEu8, 0x00u8, 0x00u8, 0x00u8, 0x16u8, 0xF3u8, 0x72u8,
+        0x0Au8, 0xC2u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x18u8, 0x15u8, 0x41u8, 0x83u8,
+        0x44u8, 0xD0u8, 0x0Au8, 0xF5u8, 0xDEu8, 0x8Bu8, 0xC1u8, 0x45u8, 0xD6u8, 0x52u8, 0xB0u8,
+        0xA1u8, 0x77u8, 0x3Bu8, 0xC1u8, 0x36u8, 0xCFu8, 0x30u8, 0x9Au8, 0xDAu8, 0xE7u8, 0x30u8,
+        0x41u8, 0x50u8, 0x54u8, 0x09u8, 0xEDu8, 0x95u8, 0x2Fu8, 0xD8u8, 0xC0u8, 0x1Eu8, 0x88u8,
+        0x6Bu8, 0xF8u8, 0x34u8, 0x4Cu8, 0x89u8, 0xC0u8, 0x58u8, 0x00u8, 0xA6u8, 0x6Fu8, 0x44u8,
+        0xC8u8, 0x58u8, 0x40u8, 0xBFu8, 0xD4u8, 0x95u8, 0x68u8, 0xFFu8, 0xFDu8, 0x18u8, 0xC0u8,
+        0xF0u8, 0x03u8, 0xFFu8, 0x88u8, 0x8Eu8, 0xB3u8, 0xCBu8, 0x3Fu8, 0xAAu8, 0xCEu8, 0x34u8,
+        0x5Du8, 0x7Fu8, 0x08u8, 0x5Bu8, 0x3Fu8, 0xF6u8, 0xEAu8, 0xCDu8, 0xEFu8, 0x05u8, 0x64u8,
+        0x4Eu8, 0xBFu8, 0x20u8, 0x04u8, 0xEFu8, 0x7Cu8, 0xF5u8, 0xF8u8, 0x14u8, 0x3Fu8, 0x12u8,
+        0x92u8, 0x05u8, 0x96u8, 0xC6u8, 0xACu8, 0xD0u8, 0xBEu8, 0x23u8, 0x55u8, 0x5Au8, 0xACu8,
+        0x1Bu8, 0x7Fu8, 0x70u8, 0x3Eu8, 0x46u8, 0x7Eu8, 0x06u8, 0xE0u8, 0x51u8, 0x7Eu8, 0x45u8,
+        0x3Eu8, 0x20u8, 0x48u8, 0xABu8, 0x3Eu8, 0xBAu8, 0x45u8, 0x5Eu8, 0xC1u8, 0xF6u8, 0xACu8,
+        0x08u8, 0x07u8, 0x31u8, 0xDEu8, 0x6Au8, 0xC1u8, 0x84u8, 0xEBu8, 0x2Au8, 0x2Cu8, 0xF3u8,
+        0xB6u8, 0x00u8, 0x41u8, 0xFFu8, 0xADu8, 0x62u8, 0xC2u8, 0x15u8, 0xFDu8, 0xE3u8, 0x40u8,
+        0xA2u8, 0xC3u8, 0xA7u8, 0xC0u8, 0x17u8, 0xF1u8, 0x9Du8, 0xC0u8, 0x08u8, 0x48u8, 0x07u8,
+        0x3Eu8, 0x2Du8, 0x74u8, 0x4Bu8, 0x40u8, 0x7Eu8, 0x47u8, 0x8Du8, 0xEDu8, 0xEFu8, 0xF4u8,
+        0xECu8, 0x3Fu8, 0xC5u8, 0xE4u8, 0x8Au8, 0x29u8, 0xE2u8, 0x0Eu8, 0xD0u8, 0xBFu8, 0x89u8,
+        0x03u8, 0x3Cu8, 0x15u8, 0x9Cu8, 0x93u8, 0x93u8, 0x3Fu8, 0xBAu8, 0xC7u8, 0x1Fu8, 0x4Cu8,
+        0xFDu8, 0xDAu8, 0x4Bu8, 0xBFu8, 0xB4u8, 0x96u8, 0x84u8, 0x50u8, 0x2Fu8, 0xFEu8, 0xDFu8,
+        0x3Eu8, 0x96u8, 0x2Bu8, 0x7Fu8, 0xD9u8, 0xBAu8, 0x76u8, 0xC5u8, 0x3Eu8, 0x68u8, 0xA5u8,
+        0x6Du8, 0x4Fu8, 0xC6u8, 0x79u8, 0x92u8, 0xBEu8, 0xF8u8, 0x29u8, 0xA8u8, 0xD2u8, 0xCFu8,
+        0xAAu8, 0x51u8, 0x3Eu8, 0x9Bu8, 0xA8u8, 0xB8u8, 0x31u8, 0x91u8, 0xF7u8, 0x3Cu8, 0x41u8,
+        0xC8u8, 0xEDu8, 0x77u8, 0x7Eu8, 0x9Au8, 0xF0u8, 0x5Bu8, 0xC1u8, 0x8Eu8, 0x1Cu8, 0x62u8,
+        0xD6u8, 0xE5u8, 0x22u8, 0xE5u8, 0xC0u8, 0x0Bu8, 0x3Au8, 0x19u8, 0xC8u8, 0x02u8, 0xDDu8,
+        0xD7u8, 0x40u8, 0x74u8, 0x06u8, 0xC5u8, 0x0Du8, 0x3Au8, 0x49u8, 0x8Du8, 0xC0u8, 0xBFu8,
+        0x46u8, 0x3Eu8, 0x59u8, 0x51u8, 0xE1u8, 0x32u8, 0x40u8, 0x45u8, 0x57u8, 0x29u8, 0x5Fu8,
+        0x00u8, 0x38u8, 0xF2u8, 0x3Fu8, 0xE0u8, 0x10u8, 0x17u8, 0x21u8, 0x14u8, 0x0Au8, 0xC4u8,
+        0xBFu8, 0x53u8, 0x05u8, 0xE7u8, 0x21u8, 0x99u8, 0x87u8, 0x84u8, 0x3Fu8, 0x04u8, 0x95u8,
+        0x0Du8, 0x54u8, 0xB5u8, 0x55u8, 0x37u8, 0xBFu8, 0x25u8, 0x48u8, 0x50u8, 0xB7u8, 0x6Du8,
+        0x2Au8, 0xD2u8, 0xBEu8, 0x4Du8, 0x7Fu8, 0x98u8, 0x21u8, 0x61u8, 0xE6u8, 0xBDu8, 0x3Eu8,
+        0x69u8, 0x94u8, 0x3Eu8, 0x65u8, 0xD7u8, 0x94u8, 0x84u8, 0xBEu8, 0x9Bu8, 0x2Eu8, 0x23u8,
+        0xD2u8, 0x9Cu8, 0x70u8, 0x40u8, 0x3Eu8, 0x00u8, 0x00u8, 0x00u8, 0xB6u8, 0x9Eu8, 0x72u8,
+        0x0Au8, 0xC2u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x18u8, 0x15u8, 0x41u8, 0x57u8,
+        0xA3u8, 0x86u8, 0x8Fu8, 0x8Au8, 0xD9u8, 0x89u8, 0xC1u8, 0xF1u8, 0xFAu8, 0x5Au8, 0x5Eu8,
+        0xDDu8, 0xFAu8, 0x55u8, 0x41u8, 0xA9u8, 0x15u8, 0xFBu8, 0x45u8, 0x7Du8, 0xB9u8, 0x27u8,
+        0x41u8, 0xB5u8, 0x1Bu8, 0xA7u8, 0xCCu8, 0x70u8, 0x6Au8, 0xDBu8, 0xC0u8, 0x1Du8, 0xADu8,
+        0x33u8, 0x05u8, 0xF0u8, 0x68u8, 0x5Eu8, 0x40u8, 0xC4u8, 0xB8u8, 0x25u8, 0xC2u8, 0xDCu8,
+        0x2Au8, 0x28u8, 0x40u8, 0x5Bu8, 0xA2u8, 0xD2u8, 0xA0u8, 0xB2u8, 0x72u8, 0xFAu8, 0xBFu8,
+        0xE7u8, 0x8Eu8, 0x5Du8, 0x05u8, 0xB3u8, 0x5Au8, 0xB7u8, 0x3Fu8, 0xD8u8, 0xB9u8, 0x7Cu8,
+        0xBBu8, 0xF9u8, 0x4Du8, 0x70u8, 0xBFu8, 0x14u8, 0x98u8, 0x53u8, 0x7Du8, 0x96u8, 0x12u8,
+        0x1Du8, 0x3Fu8, 0x28u8, 0x68u8, 0x5Au8, 0x34u8, 0xA0u8, 0x88u8, 0x95u8, 0x3Eu8, 0x2Cu8,
+        0xC2u8, 0x61u8, 0x50u8, 0xE6u8, 0xB5u8, 0x94u8, 0xBEu8, 0xC3u8, 0x38u8, 0xBAu8, 0x43u8,
+        0x2Eu8, 0xA6u8, 0x5Bu8, 0x3Eu8, 0x32u8, 0x05u8, 0x22u8, 0x7Cu8, 0xB6u8, 0x50u8, 0x13u8,
+        0xBEu8, 0x0Eu8, 0x78u8, 0x82u8, 0xFAu8, 0x67u8, 0x1Au8, 0x80u8, 0xC1u8, 0x82u8, 0x12u8,
+        0xD2u8, 0x0Cu8, 0xC1u8, 0xDDu8, 0x65u8, 0xC1u8, 0x24u8, 0x02u8, 0xBCu8, 0xD8u8, 0x75u8,
+        0x4Cu8, 0x1Du8, 0x41u8, 0xF0u8, 0xB0u8, 0xF1u8, 0x5Du8, 0x8Au8, 0x56u8, 0xD2u8, 0x40u8,
+        0x42u8, 0xFAu8, 0xE3u8, 0xE1u8, 0x2Fu8, 0xA1u8, 0x8Cu8, 0xC0u8, 0xCDu8, 0xEAu8, 0x62u8,
+        0xFEu8, 0xEDu8, 0xECu8, 0x42u8, 0x40u8, 0xDBu8, 0x67u8, 0x13u8, 0xAEu8, 0xFFu8, 0x1Du8,
+        0xF3u8, 0xBFu8, 0xB2u8, 0x70u8, 0x77u8, 0x69u8, 0xE8u8, 0x58u8, 0x84u8, 0x3Fu8, 0x11u8,
+        0x78u8, 0x77u8, 0x64u8, 0xB9u8, 0x48u8, 0x5Au8, 0x3Fu8, 0x68u8, 0xA8u8, 0xB0u8, 0xD9u8,
+        0x64u8, 0x86u8, 0x25u8, 0xBFu8, 0x9Cu8, 0x66u8, 0x86u8, 0x78u8, 0x99u8, 0x5Du8, 0xE4u8,
+        0x3Eu8, 0x91u8, 0x15u8, 0x27u8, 0x75u8, 0xE3u8, 0x7Eu8, 0x9Cu8, 0xBEu8, 0x1Cu8, 0x47u8,
+        0xC3u8, 0x1Fu8, 0x2Fu8, 0x73u8, 0x49u8, 0x3Eu8, 0x1Fu8, 0x4Au8, 0x4Bu8, 0xA9u8, 0x52u8,
+        0xD7u8, 0xFAu8, 0x3Du8, 0xC0u8, 0x9Fu8, 0xD4u8, 0xF9u8, 0x93u8, 0x82u8, 0x67u8, 0xC1u8,
+        0x01u8, 0x10u8, 0x9Fu8, 0xEAu8, 0xF7u8, 0xA1u8, 0x59u8, 0xC1u8, 0xACu8, 0x5Au8, 0xF4u8,
+        0x04u8, 0xDDu8, 0x4Au8, 0x05u8, 0x41u8, 0xC5u8, 0x1Cu8, 0xE1u8, 0x32u8, 0xEEu8, 0x51u8,
+        0xC9u8, 0x40u8, 0x2Du8, 0xAAu8, 0xF7u8, 0xBEu8, 0x2Bu8, 0x57u8, 0x7Fu8, 0xC0u8, 0x51u8,
+        0x4Fu8, 0xA6u8, 0xECu8, 0xD1u8, 0xEBu8, 0x32u8, 0x40u8, 0xB8u8, 0xC5u8, 0x12u8, 0xB5u8,
+        0x6Du8, 0xAEu8, 0xDDu8, 0xBFu8, 0xD4u8, 0x48u8, 0xB7u8, 0x4Eu8, 0x8Fu8, 0x86u8, 0x71u8,
+        0xBFu8, 0xBEu8, 0x56u8, 0xE8u8, 0x95u8, 0x10u8, 0xDEu8, 0x54u8, 0x3Fu8, 0xC8u8, 0x42u8,
+        0xF7u8, 0x0Bu8, 0xEDu8, 0x03u8, 0x1Au8, 0xBFu8, 0xD6u8, 0xFBu8, 0xAAu8, 0x43u8, 0xC9u8,
+        0x95u8, 0xD5u8, 0x3Eu8, 0xDEu8, 0xC9u8, 0xACu8, 0x7Bu8, 0xF8u8, 0x0Eu8, 0x8Au8, 0xBEu8,
+        0xD0u8, 0xBCu8, 0x09u8, 0xCFu8, 0x99u8, 0xA4u8, 0x2Du8, 0x3Eu8, 0x7Bu8, 0xEAu8, 0x63u8,
+        0x33u8, 0x3Fu8, 0x00u8, 0xE9u8, 0x3Du8, 0x00u8, 0x00u8, 0x00u8, 0x56u8, 0x4Au8, 0x72u8,
+        0x0Au8, 0xC2u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x18u8, 0x15u8, 0x41u8, 0x5Cu8,
+        0xDBu8, 0xB2u8, 0x1Cu8, 0x5Bu8, 0xE2u8, 0x81u8, 0xC1u8, 0xAAu8, 0x81u8, 0x63u8, 0x11u8,
+        0x27u8, 0x5Cu8, 0x64u8, 0x41u8, 0x20u8, 0x14u8, 0x5Eu8, 0x4Bu8, 0x00u8, 0xC6u8, 0x1Bu8,
+        0x41u8, 0xC6u8, 0x83u8, 0xE2u8, 0x99u8, 0xCFu8, 0x17u8, 0xD9u8, 0xC0u8, 0xDCu8, 0x2Bu8,
+        0x25u8, 0x5Fu8, 0x4Au8, 0x74u8, 0x5Cu8, 0x40u8, 0xA0u8, 0x80u8, 0xD1u8, 0x47u8, 0xEFu8,
+        0xB3u8, 0x1Fu8, 0xC0u8, 0xFBu8, 0x1Eu8, 0xC2u8, 0x02u8, 0xDCu8, 0x16u8, 0xD6u8, 0xBFu8,
+        0x78u8, 0xDFu8, 0x40u8, 0xF9u8, 0x33u8, 0x1Au8, 0x92u8, 0x3Fu8, 0x04u8, 0xE9u8, 0xC9u8,
+        0x3Cu8, 0x6Cu8, 0x41u8, 0x51u8, 0xBFu8, 0xA4u8, 0x07u8, 0x64u8, 0x4Du8, 0x05u8, 0xABu8,
+        0x07u8, 0x3Fu8, 0xF8u8, 0x8Bu8, 0xA1u8, 0xC3u8, 0x79u8, 0x3Du8, 0xB8u8, 0xBEu8, 0x65u8,
+        0x02u8, 0xD3u8, 0x06u8, 0xE0u8, 0x43u8, 0x66u8, 0x3Eu8, 0x3Au8, 0x21u8, 0x1Du8, 0xAAu8,
+        0x84u8, 0xB0u8, 0x05u8, 0x3Eu8, 0xE1u8, 0xAFu8, 0x7Du8, 0xC6u8, 0x43u8, 0xB9u8, 0xD6u8,
+        0x3Du8, 0xA5u8, 0xDEu8, 0x56u8, 0x72u8, 0xF7u8, 0xEEu8, 0x88u8, 0xC1u8, 0xC7u8, 0xCAu8,
+        0xE3u8, 0x08u8, 0x68u8, 0x69u8, 0x5Au8, 0xC1u8, 0x15u8, 0x6Cu8, 0x6Du8, 0x05u8, 0x6Du8,
+        0x76u8, 0x23u8, 0x41u8, 0xD6u8, 0x78u8, 0x8Du8, 0xF8u8, 0x98u8, 0x1Fu8, 0xC1u8, 0x40u8,
+        0x34u8, 0x15u8, 0x73u8, 0x72u8, 0x35u8, 0x93u8, 0x79u8, 0xC0u8, 0xA8u8, 0x15u8, 0x3Du8,
+        0xCDu8, 0x8Eu8, 0x99u8, 0x2Du8, 0x40u8, 0x40u8, 0x35u8, 0x50u8, 0x02u8, 0xFCu8, 0xFCu8,
+        0xE6u8, 0xBFu8, 0xB1u8, 0x90u8, 0x86u8, 0x53u8, 0x5Fu8, 0x1Au8, 0x8Du8, 0x3Fu8, 0xECu8,
+        0xC1u8, 0x7Du8, 0x8Bu8, 0xBBu8, 0xB5u8, 0x3Eu8, 0xBFu8, 0xBAu8, 0xFBu8, 0x28u8, 0xC8u8,
+        0x77u8, 0xD8u8, 0xDFu8, 0xBEu8, 0x44u8, 0x80u8, 0x24u8, 0xE1u8, 0xC3u8, 0x18u8, 0xAAu8,
+        0x3Eu8, 0xE1u8, 0x47u8, 0xFDu8, 0x8Du8, 0xBCu8, 0x6Eu8, 0x70u8, 0xBEu8, 0x90u8, 0xBBu8,
+        0x1Au8, 0xEEu8, 0x97u8, 0xDCu8, 0x26u8, 0x3Eu8, 0x5Bu8, 0x74u8, 0xFDu8, 0xE3u8, 0x04u8,
+        0xBEu8, 0x10u8, 0xBEu8, 0x25u8, 0x11u8, 0x1Fu8, 0x5Fu8, 0xCDu8, 0xD8u8, 0x76u8, 0xC1u8,
+        0xACu8, 0x90u8, 0xEAu8, 0x7Fu8, 0x7Fu8, 0x5Cu8, 0x52u8, 0xC1u8, 0x10u8, 0xF8u8, 0x95u8,
+        0x0Du8, 0xCAu8, 0xD8u8, 0x11u8, 0x41u8, 0x68u8, 0xEFu8, 0x20u8, 0x49u8, 0x3Fu8, 0xCEu8,
+        0xBCu8, 0x40u8, 0x6Eu8, 0xB2u8, 0x3Eu8, 0xCCu8, 0x02u8, 0xC7u8, 0x6Cu8, 0xC0u8, 0x70u8,
+        0x14u8, 0x43u8, 0x32u8, 0xF3u8, 0x73u8, 0x21u8, 0x40u8, 0x28u8, 0x1Eu8, 0x0Du8, 0x05u8,
+        0x6Eu8, 0x34u8, 0xD6u8, 0xBFu8, 0xFAu8, 0x27u8, 0xC1u8, 0x3Eu8, 0xE4u8, 0x71u8, 0x77u8,
+        0x3Fu8, 0xC4u8, 0xF7u8, 0x66u8, 0xAAu8, 0x9Cu8, 0x44u8, 0x22u8, 0xBFu8, 0xE3u8, 0xE1u8,
+        0x1Eu8, 0x29u8, 0x9Fu8, 0x6Fu8, 0xE2u8, 0xBEu8, 0x6Bu8, 0xBEu8, 0x96u8, 0xF4u8, 0x21u8,
+        0xFFu8, 0xA2u8, 0x3Eu8, 0x21u8, 0x59u8, 0xF2u8, 0x2Au8, 0x06u8, 0xDFu8, 0x63u8, 0xBEu8,
+        0x13u8, 0x33u8, 0x3Fu8, 0xCDu8, 0xC4u8, 0xADu8, 0x1Du8, 0x3Eu8, 0x06u8, 0xF6u8, 0x9Fu8,
+        0xE9u8, 0x30u8, 0x4Au8, 0x87u8, 0x3Du8, 0x00u8, 0x00u8, 0x00u8, 0xF6u8, 0xF5u8, 0x71u8,
+        0x0Au8, 0xC2u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x18u8, 0x15u8, 0x41u8, 0xD8u8,
+        0x85u8, 0xCFu8, 0xD1u8, 0x4Eu8, 0xB6u8, 0x69u8, 0xC1u8, 0xAFu8, 0x2Fu8, 0x62u8, 0xCFu8,
+        0x86u8, 0xFBu8, 0x68u8, 0x41u8, 0x38u8, 0xB2u8, 0x47u8, 0xD8u8, 0x07u8, 0x77u8, 0x02u8,
+        0x41u8, 0x86u8, 0x05u8, 0xC8u8, 0x23u8, 0x25u8, 0xE1u8, 0xD8u8, 0xC0u8, 0xCAu8, 0x3Bu8,
+        0xECu8, 0x19u8, 0x32u8, 0x7Bu8, 0x59u8, 0xC0u8, 0x5Eu8, 0x37u8, 0xCEu8, 0x8Bu8, 0x96u8,
+        0xC7u8, 0x29u8, 0xC0u8, 0x79u8, 0x8Cu8, 0x61u8, 0x55u8, 0x9Au8, 0x98u8, 0xC1u8, 0xBFu8,
+        0xFDu8, 0x62u8, 0x9Eu8, 0xCEu8, 0xBBu8, 0xF0u8, 0x61u8, 0x3Fu8, 0x47u8, 0xB9u8, 0x0Au8,
+        0x32u8, 0x00u8, 0xFFu8, 0x0Fu8, 0xBFu8, 0x0Du8, 0x87u8, 0x07u8, 0x6Bu8, 0x72u8, 0x2Fu8,
+        0xF5u8, 0x3Eu8, 0xFFu8, 0x9Fu8, 0x6Bu8, 0x6Eu8, 0x0Eu8, 0xA5u8, 0x80u8, 0x3Eu8, 0xBDu8,
+        0x0Eu8, 0x9Cu8, 0xC1u8, 0xACu8, 0x54u8, 0x62u8, 0x3Eu8, 0x6Eu8, 0x0Bu8, 0xCCu8, 0x45u8,
+        0x4Cu8, 0xCEu8, 0xD0u8, 0x3Du8, 0x2Cu8, 0x75u8, 0x92u8, 0x7Au8, 0x86u8, 0xD2u8, 0xD2u8,
+        0xBDu8, 0xD8u8, 0xBBu8, 0x4Du8, 0xFDu8, 0x0Du8, 0xFAu8, 0x8Cu8, 0xC1u8, 0x4Au8, 0xA7u8,
+        0xD0u8, 0xAFu8, 0xA2u8, 0xD0u8, 0x36u8, 0xC1u8, 0x66u8, 0x2Eu8, 0x69u8, 0x0Eu8, 0x56u8,
+        0xB0u8, 0x25u8, 0x41u8, 0x57u8, 0x4Du8, 0x96u8, 0x95u8, 0x29u8, 0x54u8, 0xADu8, 0x40u8,
+        0x5Cu8, 0xECu8, 0xE6u8, 0x51u8, 0xF7u8, 0x6Bu8, 0x70u8, 0xC0u8, 0xB8u8, 0x41u8, 0x3Fu8,
+        0x7Au8, 0xD4u8, 0x2Eu8, 0xE0u8, 0x3Fu8, 0x14u8, 0x9Fu8, 0x3Bu8, 0x6Au8, 0xB5u8, 0x9Au8,
+        0xE1u8, 0xBFu8, 0x63u8, 0xEFu8, 0x81u8, 0xAAu8, 0x81u8, 0xA5u8, 0x65u8, 0xBFu8, 0x7Du8,
+        0x5Eu8, 0x6Cu8, 0xE9u8, 0xF3u8, 0xD4u8, 0x42u8, 0xBFu8, 0xBBu8, 0xB8u8, 0x71u8, 0xC1u8,
+        0x03u8, 0x92u8, 0xD2u8, 0xBEu8, 0x7Bu8, 0x06u8, 0xD1u8, 0x18u8, 0x16u8, 0x58u8, 0x8Eu8,
+        0xBEu8, 0x61u8, 0xCBu8, 0xEEu8, 0xAAu8, 0x53u8, 0xD9u8, 0x21u8, 0xBEu8, 0xE9u8, 0xDAu8,
+        0xAFu8, 0xA5u8, 0x77u8, 0x26u8, 0x21u8, 0x3Eu8, 0xBCu8, 0xBAu8, 0x96u8, 0xB0u8, 0xC5u8,
+        0x5Bu8, 0xE8u8, 0xBDu8, 0xB8u8, 0x93u8, 0x3Fu8, 0x49u8, 0x9Du8, 0x90u8, 0x7Du8, 0xC1u8,
+        0xA7u8, 0x10u8, 0x9Au8, 0x5Fu8, 0x92u8, 0x92u8, 0x40u8, 0xC1u8, 0xFBu8, 0x91u8, 0xF6u8,
+        0xBFu8, 0x1Du8, 0x2Bu8, 0x16u8, 0x41u8, 0x04u8, 0x0Bu8, 0xBDu8, 0xF7u8, 0x45u8, 0x45u8,
+        0xB2u8, 0x40u8, 0xEBu8, 0xD7u8, 0xE3u8, 0xEEu8, 0x62u8, 0x2Eu8, 0x60u8, 0xC0u8, 0x96u8,
+        0xF9u8, 0xCDu8, 0x55u8, 0x1Eu8, 0xF8u8, 0xF9u8, 0x3Fu8, 0x09u8, 0xCAu8, 0xFEu8, 0x19u8,
+        0x51u8, 0xDBu8, 0xD1u8, 0xBFu8, 0x8Fu8, 0x28u8, 0xD4u8, 0x76u8, 0x1Du8, 0xDCu8, 0x5Au8,
+        0xBFu8, 0xF4u8, 0x13u8, 0xA7u8, 0xFFu8, 0x83u8, 0xABu8, 0x33u8, 0xBFu8, 0xFAu8, 0x94u8,
+        0x72u8, 0x7Du8, 0xEFu8, 0xCDu8, 0xD2u8, 0xBEu8, 0x62u8, 0xD9u8, 0x59u8, 0xD1u8, 0x98u8,
+        0xD3u8, 0x81u8, 0xBEu8, 0x41u8, 0x4Eu8, 0xE8u8, 0xE1u8, 0xFDu8, 0x1Fu8, 0x34u8, 0xBEu8,
+        0x3Au8, 0x5Cu8, 0x3Fu8, 0xAFu8, 0x17u8, 0xBFu8, 0xECu8, 0x3Du8, 0xD3u8, 0x50u8, 0x63u8,
+        0xA0u8, 0xD3u8, 0xD3u8, 0xDBu8, 0x3Du8, 0x00u8, 0x00u8, 0x00u8, 0x96u8, 0xA1u8, 0x71u8,
+        0x0Au8, 0xC2u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x18u8, 0x15u8, 0x41u8, 0xABu8,
+        0xAFu8, 0x7Bu8, 0xC0u8, 0xBAu8, 0xA6u8, 0x68u8, 0x41u8, 0x87u8, 0xDCu8, 0xD9u8, 0x38u8,
+        0xAFu8, 0xDDu8, 0x68u8, 0x41u8, 0x3Fu8, 0x44u8, 0x95u8, 0x65u8, 0x55u8, 0x26u8, 0x05u8,
+        0xC1u8, 0xE6u8, 0x69u8, 0x86u8, 0xD6u8, 0xA3u8, 0xA2u8, 0xDCu8, 0xC0u8, 0xC8u8, 0x84u8,
+        0x04u8, 0xDAu8, 0x71u8, 0x1Au8, 0x78u8, 0xC0u8, 0x2Du8, 0x61u8, 0x44u8, 0x07u8, 0xD2u8,
+        0xC5u8, 0x2Du8, 0xC0u8, 0x6Au8, 0x8Au8, 0x26u8, 0xE5u8, 0xCAu8, 0x6Cu8, 0xA0u8, 0x3Fu8,
+        0x03u8, 0x27u8, 0xAFu8, 0xE3u8, 0xAEu8, 0xADu8, 0x90u8, 0x3Fu8, 0xCAu8, 0x58u8, 0x26u8,
+        0x13u8, 0x41u8, 0xB7u8, 0x53u8, 0x3Fu8, 0x7Fu8, 0x66u8, 0x73u8, 0x2Au8, 0xF5u8, 0x3Du8,
+        0x11u8, 0x3Fu8, 0xB3u8, 0xF8u8, 0xE9u8, 0x5Du8, 0x8Au8, 0x68u8, 0xC5u8, 0x3Eu8, 0xBEu8,
+        0x44u8, 0x8Cu8, 0xDDu8, 0x90u8, 0x4Bu8, 0x77u8, 0x3Eu8, 0x5Bu8, 0xF2u8, 0x92u8, 0x50u8,
+        0xF9u8, 0xC7u8, 0x18u8, 0x3Eu8, 0xFDu8, 0x39u8, 0xC0u8, 0x4Fu8, 0x5Eu8, 0x50u8, 0xD7u8,
+        0x3Du8, 0xB5u8, 0xB6u8, 0x9Bu8, 0x2Bu8, 0x1Du8, 0xA6u8, 0x8Bu8, 0xC1u8, 0x6Eu8, 0x0Cu8,
+        0x8Eu8, 0x36u8, 0x47u8, 0x62u8, 0x50u8, 0x41u8, 0xFDu8, 0x38u8, 0xD3u8, 0x57u8, 0x64u8,
+        0x3Au8, 0x26u8, 0x41u8, 0x89u8, 0x68u8, 0xC5u8, 0x11u8, 0x6Du8, 0xFDu8, 0x91u8, 0xC0u8,
+        0x7Fu8, 0xF9u8, 0x96u8, 0x98u8, 0xC4u8, 0x23u8, 0x79u8, 0xC0u8, 0x3Au8, 0x4Eu8, 0xD8u8,
+        0x7Fu8, 0xF0u8, 0xBBu8, 0x2Fu8, 0xC0u8, 0xFFu8, 0xADu8, 0xD7u8, 0x4Eu8, 0xEBu8, 0x50u8,
+        0xEDu8, 0xBFu8, 0xDCu8, 0x25u8, 0xB6u8, 0x7Eu8, 0x67u8, 0x7Bu8, 0x99u8, 0xBFu8, 0x8Bu8,
+        0xF1u8, 0x78u8, 0xD2u8, 0x61u8, 0xBDu8, 0x4Au8, 0xBFu8, 0x85u8, 0x6Au8, 0x1Fu8, 0xE7u8,
+        0x1Du8, 0xD8u8, 0xC3u8, 0xBEu8, 0x7Cu8, 0x37u8, 0xD7u8, 0x75u8, 0xCFu8, 0x68u8, 0xAEu8,
+        0x3Eu8, 0x60u8, 0x42u8, 0x77u8, 0x14u8, 0x80u8, 0xB9u8, 0x76u8, 0x3Eu8, 0x51u8, 0xC2u8,
+        0xBDu8, 0x3Eu8, 0xE0u8, 0x5Du8, 0x32u8, 0x3Eu8, 0x50u8, 0x94u8, 0xDBu8, 0xA6u8, 0x31u8,
+        0xA1u8, 0x06u8, 0x3Eu8, 0x35u8, 0x1Eu8, 0xEBu8, 0x9Fu8, 0x88u8, 0xCAu8, 0x7Eu8, 0xC1u8,
+        0x97u8, 0xF3u8, 0xA0u8, 0x66u8, 0x98u8, 0x28u8, 0x2Cu8, 0x41u8, 0x97u8, 0xA8u8, 0x28u8,
+        0x69u8, 0xC6u8, 0xD2u8, 0x18u8, 0x41u8, 0xCCu8, 0xDAu8, 0x42u8, 0xFBu8, 0xF9u8, 0x40u8,
+        0xA3u8, 0x40u8, 0xBCu8, 0x7Bu8, 0x08u8, 0xCAu8, 0x09u8, 0xC2u8, 0x65u8, 0xC0u8, 0x7Eu8,
+        0xFFu8, 0xB6u8, 0x8Fu8, 0x38u8, 0x9Au8, 0x1Bu8, 0xC0u8, 0x11u8, 0x8Bu8, 0x88u8, 0x29u8,
+        0x7Cu8, 0x7Du8, 0xDFu8, 0xBFu8, 0xDBu8, 0xA2u8, 0x1Au8, 0x9Cu8, 0xC6u8, 0xAFu8, 0x8Eu8,
+        0xBFu8, 0xBAu8, 0x6Cu8, 0xC5u8, 0xFDu8, 0x2Fu8, 0x67u8, 0x42u8, 0xBFu8, 0xB2u8, 0x5Cu8,
+        0xD0u8, 0xDDu8, 0x60u8, 0x20u8, 0xE1u8, 0xBEu8, 0xC2u8, 0x57u8, 0x43u8, 0x75u8, 0x8Bu8,
+        0xF9u8, 0x8Cu8, 0x3Eu8, 0xA4u8, 0xEBu8, 0x54u8, 0xB2u8, 0x6Au8, 0x69u8, 0x63u8, 0x3Eu8,
+        0x78u8, 0xD1u8, 0x36u8, 0x30u8, 0xEAu8, 0x34u8, 0x20u8, 0x3Eu8, 0x94u8, 0xBEu8, 0xCBu8,
+        0x79u8, 0x94u8, 0x90u8, 0xD2u8, 0x3Du8, 0x00u8, 0x00u8, 0x00u8, 0x36u8, 0x4Du8, 0x71u8,
+        0x0Au8, 0xC2u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x18u8, 0x15u8, 0x41u8, 0x69u8,
+        0x96u8, 0x0Bu8, 0x34u8, 0x8Fu8, 0x5Cu8, 0x81u8, 0x41u8, 0x19u8, 0x66u8, 0x8Cu8, 0xE2u8,
+        0x19u8, 0x4Cu8, 0x63u8, 0x41u8, 0x82u8, 0x19u8, 0xBCu8, 0xD6u8, 0x1Eu8, 0x6Eu8, 0x21u8,
+        0xC1u8, 0xBEu8, 0x9Fu8, 0x86u8, 0xBCu8, 0x65u8, 0x57u8, 0xE2u8, 0xC0u8, 0x50u8, 0x1Cu8,
+        0xFEu8, 0xE0u8, 0x3Eu8, 0xDEu8, 0x82u8, 0xC0u8, 0x46u8, 0xDBu8, 0xEAu8, 0x8Cu8, 0xAFu8,
+        0x54u8, 0xF3u8, 0xBFu8, 0x90u8, 0x39u8, 0xD0u8, 0x89u8, 0xA4u8, 0x16u8, 0xF9u8, 0x3Fu8,
+        0xFDu8, 0x95u8, 0x6Fu8, 0xB0u8, 0x69u8, 0xACu8, 0xBEu8, 0x3Fu8, 0x16u8, 0xE6u8, 0x27u8,
+        0xF4u8, 0xBBu8, 0xA0u8, 0x79u8, 0x3Fu8, 0x17u8, 0x87u8, 0x3Eu8, 0xB3u8, 0xA5u8, 0x21u8,
+        0x2Du8, 0x3Fu8, 0xD3u8, 0x4Au8, 0xB2u8, 0x83u8, 0x1Au8, 0xE5u8, 0xC3u8, 0x3Eu8, 0x60u8,
+        0x16u8, 0x8Du8, 0x53u8, 0x6Eu8, 0x84u8, 0x9Bu8, 0xBEu8, 0xCCu8, 0x7Fu8, 0x8Fu8, 0xECu8,
+        0x07u8, 0xCCu8, 0x66u8, 0xBEu8, 0x69u8, 0x1Eu8, 0x97u8, 0x04u8, 0xDBu8, 0x63u8, 0x22u8,
+        0xBEu8, 0xD4u8, 0xA6u8, 0xE6u8, 0x51u8, 0xA7u8, 0xD7u8, 0x84u8, 0xC1u8, 0xDCu8, 0x8Fu8,
+        0x84u8, 0xF1u8, 0xAFu8, 0xEDu8, 0x62u8, 0x41u8, 0x2Du8, 0xFFu8, 0x03u8, 0xA7u8, 0xB9u8,
+        0x2Au8, 0x24u8, 0x41u8, 0xF1u8, 0xE3u8, 0x44u8, 0x77u8, 0x78u8, 0xABu8, 0xC6u8, 0xC0u8,
+        0x54u8, 0xA7u8, 0x83u8, 0x27u8, 0x78u8, 0x8Du8, 0x8Fu8, 0xC0u8, 0x46u8, 0xD5u8, 0x6Au8,
+        0x57u8, 0xF3u8, 0x5Au8, 0x48u8, 0xC0u8, 0x1Cu8, 0x67u8, 0xA2u8, 0x5Bu8, 0xB0u8, 0xEDu8,
+        0xFDu8, 0xBFu8, 0x1Eu8, 0x0Eu8, 0x41u8, 0x8Du8, 0x9Bu8, 0x59u8, 0xA0u8, 0xBFu8, 0xEFu8,
+        0x30u8, 0xFEu8, 0x72u8, 0x5Au8, 0x1Cu8, 0x5Bu8, 0x3Fu8, 0xD5u8, 0x72u8, 0x75u8, 0xA0u8,
+        0x0Du8, 0x51u8, 0x2Eu8, 0x3Fu8, 0x31u8, 0x4Cu8, 0xD7u8, 0xFFu8, 0xE2u8, 0x32u8, 0xF0u8,
+        0x3Eu8, 0x5Au8, 0xA6u8, 0x06u8, 0x8Du8, 0x61u8, 0x45u8, 0xA8u8, 0x3Eu8, 0x26u8, 0xB8u8,
+        0x91u8, 0xABu8, 0xDAu8, 0xA7u8, 0x54u8, 0x3Eu8, 0x21u8, 0x86u8, 0x5Bu8, 0x3Cu8, 0xBFu8,
+        0x3Au8, 0x00u8, 0xBEu8, 0x8Fu8, 0xB0u8, 0x51u8, 0xEFu8, 0x66u8, 0xE1u8, 0x79u8, 0xC1u8,
+        0x89u8, 0x54u8, 0x05u8, 0x57u8, 0x97u8, 0x24u8, 0x50u8, 0x41u8, 0xA7u8, 0x5Eu8, 0x33u8,
+        0xEDu8, 0x98u8, 0x2Cu8, 0x19u8, 0x41u8, 0xC3u8, 0x7Bu8, 0x79u8, 0x84u8, 0xBAu8, 0x8Eu8,
+        0xA1u8, 0xC0u8, 0xADu8, 0xFBu8, 0xB3u8, 0x62u8, 0xD5u8, 0xB2u8, 0x7Du8, 0xC0u8, 0x97u8,
+        0xDEu8, 0x5Eu8, 0x31u8, 0x04u8, 0xDBu8, 0x39u8, 0xC0u8, 0x40u8, 0x1Bu8, 0x6Eu8, 0x8Eu8,
+        0x18u8, 0x99u8, 0xF2u8, 0xBFu8, 0xDEu8, 0x47u8, 0x4Cu8, 0x81u8, 0xFCu8, 0x52u8, 0x9Eu8,
+        0xBFu8, 0xADu8, 0x20u8, 0x5Bu8, 0x4Bu8, 0xBBu8, 0x95u8, 0x2Du8, 0x3Fu8, 0x6Bu8, 0xAFu8,
+        0x89u8, 0x94u8, 0x9Au8, 0x39u8, 0x1Au8, 0x3Fu8, 0x46u8, 0x4Eu8, 0xFAu8, 0x9Bu8, 0xADu8,
+        0xC1u8, 0xE0u8, 0x3Eu8, 0x84u8, 0x49u8, 0xBDu8, 0x3Bu8, 0x53u8, 0xC7u8, 0x9Cu8, 0x3Eu8,
+        0xD7u8, 0xA2u8, 0xB9u8, 0x5Cu8, 0x07u8, 0xEDu8, 0x50u8, 0x3Eu8, 0xB4u8, 0x98u8, 0xECu8,
+        0x71u8, 0x98u8, 0xA1u8, 0xF3u8, 0xBDu8, 0x00u8, 0x00u8, 0x00u8, 0xD6u8, 0xF8u8, 0x70u8,
+        0x0Au8, 0xC2u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x18u8, 0x15u8, 0x41u8, 0x3Eu8,
+        0x9Eu8, 0xB1u8, 0x50u8, 0xE3u8, 0x19u8, 0x88u8, 0x41u8, 0x22u8, 0xFAu8, 0xD9u8, 0xF1u8,
+        0x1Du8, 0x77u8, 0x4Bu8, 0x41u8, 0x63u8, 0xD5u8, 0xE5u8, 0x5Cu8, 0xBBu8, 0x52u8, 0x30u8,
+        0xC1u8, 0x6Du8, 0x6Cu8, 0xE6u8, 0x29u8, 0x23u8, 0x5Bu8, 0xE5u8, 0xC0u8, 0x3Bu8, 0xE2u8,
+        0xE4u8, 0x1Au8, 0x2Fu8, 0x9Fu8, 0x64u8, 0x40u8, 0x25u8, 0x4Fu8, 0x44u8, 0x52u8, 0x04u8,
+        0x5Au8, 0x5Au8, 0x40u8, 0x38u8, 0xE7u8, 0xB5u8, 0x64u8, 0x01u8, 0x1Cu8, 0x21u8, 0x40u8,
+        0x04u8, 0xC4u8, 0x36u8, 0x74u8, 0xFBu8, 0x6Au8, 0xD7u8, 0x3Fu8, 0x3Eu8, 0xF7u8, 0xC1u8,
+        0xF4u8, 0x20u8, 0x1Fu8, 0x4Au8, 0x3Fu8, 0x4Bu8, 0xEBu8, 0x85u8, 0xE8u8, 0x82u8, 0xA5u8,
+        0x56u8, 0xBFu8, 0xFEu8, 0x46u8, 0x18u8, 0x9Du8, 0x60u8, 0x6Au8, 0x21u8, 0xBFu8, 0x18u8,
+        0xA9u8, 0xACu8, 0x55u8, 0x80u8, 0x2Bu8, 0xDCu8, 0xBEu8, 0xA0u8, 0x92u8, 0xA9u8, 0xC8u8,
+        0xAFu8, 0xE2u8, 0x6Fu8, 0xBEu8, 0x57u8, 0x09u8, 0xAFu8, 0x63u8, 0x57u8, 0xC5u8, 0x59u8,
+        0x3Eu8, 0x7Du8, 0x98u8, 0x76u8, 0x1Bu8, 0x64u8, 0x60u8, 0x72u8, 0xC1u8, 0x09u8, 0xFAu8,
+        0x9Eu8, 0x86u8, 0xBFu8, 0x40u8, 0x6Bu8, 0x41u8, 0xD5u8, 0x54u8, 0x20u8, 0xD9u8, 0xFDu8,
+        0x74u8, 0x17u8, 0x41u8, 0xD3u8, 0x20u8, 0x3Fu8, 0xD1u8, 0xA4u8, 0x92u8, 0xE2u8, 0xC0u8,
+        0x7Au8, 0x16u8, 0x5Fu8, 0x1Au8, 0x46u8, 0xE9u8, 0xA2u8, 0xC0u8, 0x01u8, 0x16u8, 0x61u8,
+        0xDFu8, 0xF5u8, 0x2Bu8, 0x55u8, 0xC0u8, 0x71u8, 0x4Bu8, 0xECu8, 0xA4u8, 0x01u8, 0x48u8,
+        0xDEu8, 0x3Fu8, 0xCAu8, 0xBCu8, 0x3Au8, 0x41u8, 0xABu8, 0xB9u8, 0xD5u8, 0x3Fu8, 0xA9u8,
+        0x9Au8, 0xA3u8, 0xC0u8, 0x60u8, 0x2Cu8, 0x9Du8, 0x3Fu8, 0xADu8, 0x50u8, 0x12u8, 0x09u8,
+        0xC9u8, 0xE2u8, 0x54u8, 0x3Fu8, 0x35u8, 0xB4u8, 0x41u8, 0xF9u8, 0x92u8, 0xB2u8, 0xB4u8,
+        0x3Eu8, 0x32u8, 0xE8u8, 0xC8u8, 0xF1u8, 0x5Du8, 0x77u8, 0xD6u8, 0xBEu8, 0x02u8, 0x67u8,
+        0x11u8, 0xD8u8, 0x4Du8, 0x89u8, 0xA1u8, 0xBEu8, 0x77u8, 0x4Eu8, 0xA7u8, 0xE0u8, 0xBEu8,
+        0x3Du8, 0x5Du8, 0xBEu8, 0xF7u8, 0x36u8, 0x06u8, 0x33u8, 0x52u8, 0xB9u8, 0x6Du8, 0xC1u8,
+        0xA4u8, 0xF3u8, 0x31u8, 0xF5u8, 0x40u8, 0xA2u8, 0x5Bu8, 0x41u8, 0xB2u8, 0xA3u8, 0x01u8,
+        0x84u8, 0x01u8, 0x5Eu8, 0x13u8, 0x41u8, 0x2Eu8, 0xB5u8, 0x60u8, 0xF2u8, 0x8Fu8, 0xA8u8,
+        0xCEu8, 0xC0u8, 0x83u8, 0xB5u8, 0x53u8, 0x60u8, 0xFDu8, 0x71u8, 0x94u8, 0xC0u8, 0x10u8,
+        0x05u8, 0x04u8, 0x5Au8, 0x9Au8, 0x1Eu8, 0x4Cu8, 0xC0u8, 0x0Cu8, 0x9Du8, 0xECu8, 0x2Bu8,
+        0x59u8, 0xAAu8, 0xE4u8, 0xBFu8, 0x00u8, 0xF3u8, 0xEFu8, 0xDAu8, 0x61u8, 0x42u8, 0xC2u8,
+        0x3Fu8, 0x99u8, 0x80u8, 0xC1u8, 0x14u8, 0x70u8, 0xF3u8, 0x8Eu8, 0x3Fu8, 0xF3u8, 0x07u8,
+        0xA2u8, 0xE6u8, 0x5Du8, 0x09u8, 0x4Bu8, 0x3Fu8, 0x29u8, 0xB8u8, 0x3Cu8, 0xDFu8, 0x7Fu8,
+        0xA2u8, 0xEEu8, 0x3Eu8, 0xDAu8, 0x9Du8, 0xD5u8, 0x78u8, 0x48u8, 0x0Du8, 0xC2u8, 0xBEu8,
+        0x09u8, 0xE0u8, 0x60u8, 0xD1u8, 0x5Cu8, 0x42u8, 0x92u8, 0xBEu8, 0x48u8, 0x45u8, 0x45u8,
+        0x7Au8, 0xC7u8, 0x29u8, 0x52u8, 0xBEu8, 0x00u8, 0x00u8, 0x00u8, 0x76u8, 0xA4u8, 0x70u8,
+        0x0Au8, 0xC2u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x18u8, 0x15u8, 0x41u8, 0x69u8,
+        0x53u8, 0x15u8, 0xCBu8, 0x9Au8, 0xC0u8, 0x86u8, 0x41u8, 0x8Cu8, 0x1Cu8, 0x99u8, 0x39u8,
+        0x43u8, 0xCFu8, 0x59u8, 0xC1u8, 0x05u8, 0x48u8, 0x1Fu8, 0x84u8, 0x06u8, 0x5Du8, 0x36u8,
+        0xC1u8, 0xBAu8, 0x81u8, 0x5Fu8, 0xD6u8, 0xEFu8, 0xAAu8, 0xC4u8, 0xC0u8, 0x0Cu8, 0xE2u8,
+        0x52u8, 0x28u8, 0x36u8, 0xC7u8, 0xB2u8, 0x40u8, 0xDEu8, 0x99u8, 0x36u8, 0x3Bu8, 0x89u8,
+        0x7Fu8, 0x75u8, 0x40u8, 0x5Au8, 0xD6u8, 0x8Du8, 0x75u8, 0xBCu8, 0x65u8, 0x03u8, 0x40u8,
+        0x91u8, 0x13u8, 0x66u8, 0x9Fu8, 0xF6u8, 0x60u8, 0xFAu8, 0xBFu8, 0xBBu8, 0x8Du8, 0xC9u8,
+        0x32u8, 0x5Au8, 0x6Cu8, 0xC2u8, 0xBFu8, 0x85u8, 0x37u8, 0x4Du8, 0x87u8, 0x76u8, 0x35u8,
+        0x5Bu8, 0xBFu8, 0x92u8, 0x52u8, 0x09u8, 0x8Cu8, 0xEBu8, 0x61u8, 0x49u8, 0x3Fu8, 0xFFu8,
+        0x90u8, 0x33u8, 0x5Eu8, 0x7Bu8, 0xE6u8, 0x13u8, 0x3Fu8, 0x4Cu8, 0xF1u8, 0x8Cu8, 0x68u8,
+        0x87u8, 0x6Du8, 0xB4u8, 0x3Eu8, 0xB5u8, 0x38u8, 0x9Bu8, 0x68u8, 0xE1u8, 0x0Du8, 0x9Cu8,
+        0xBEu8, 0x09u8, 0xC6u8, 0x8Eu8, 0x2Au8, 0x72u8, 0xD8u8, 0x63u8, 0x41u8, 0x56u8, 0x7Du8,
+        0x26u8, 0xF6u8, 0x57u8, 0x30u8, 0x6Cu8, 0x41u8, 0xC4u8, 0xC1u8, 0xECu8, 0xCFu8, 0x4Au8,
+        0x02u8, 0x15u8, 0xC1u8, 0xC8u8, 0x61u8, 0x2Fu8, 0xE2u8, 0x2Cu8, 0x90u8, 0xF4u8, 0xC0u8,
+        0x66u8, 0x9Fu8, 0x66u8, 0x77u8, 0xC1u8, 0x2Fu8, 0xA4u8, 0xC0u8, 0x8Cu8, 0x6Au8, 0x1Fu8,
+        0x82u8, 0xF8u8, 0x99u8, 0x64u8, 0x40u8, 0xC2u8, 0xE6u8, 0x4Cu8, 0x52u8, 0x2Eu8, 0x4Eu8,
+        0x38u8, 0x40u8, 0x8Fu8, 0x98u8, 0x63u8, 0x7Eu8, 0x17u8, 0x7Fu8, 0xEFu8, 0x3Fu8, 0x6Cu8,
+        0xBDu8, 0x2Fu8, 0xCEu8, 0xC7u8, 0x79u8, 0xAFu8, 0xBFu8, 0xBBu8, 0x07u8, 0x04u8, 0xCAu8,
+        0x23u8, 0x68u8, 0x86u8, 0xBFu8, 0x31u8, 0x9Cu8, 0x35u8, 0x39u8, 0x91u8, 0xDEu8, 0x40u8,
+        0xBFu8, 0x39u8, 0xC9u8, 0xAFu8, 0xECu8, 0x80u8, 0xE5u8, 0xFDu8, 0x3Eu8, 0xC2u8, 0x28u8,
+        0xDFu8, 0xCCu8, 0x08u8, 0xB9u8, 0xD8u8, 0x3Eu8, 0x98u8, 0x51u8, 0x00u8, 0xFFu8, 0x0Fu8,
+        0xF1u8, 0x94u8, 0x3Eu8, 0xF9u8, 0xA4u8, 0xD9u8, 0x8Cu8, 0xDDu8, 0x8Cu8, 0x20u8, 0x41u8,
+        0x0Eu8, 0x0Au8, 0xBAu8, 0x0Du8, 0x55u8, 0x64u8, 0x60u8, 0x41u8, 0x4Du8, 0xF0u8, 0x61u8,
+        0x14u8, 0xCCu8, 0x07u8, 0xDDu8, 0xC0u8, 0xBAu8, 0x28u8, 0xBCu8, 0xF8u8, 0xFBu8, 0x64u8,
+        0xE5u8, 0xC0u8, 0x55u8, 0x35u8, 0x9Fu8, 0xF2u8, 0xDDu8, 0x6Bu8, 0x9Du8, 0xC0u8, 0xDBu8,
+        0xE1u8, 0xA7u8, 0x81u8, 0x04u8, 0xE6u8, 0x49u8, 0x40u8, 0x26u8, 0x14u8, 0xC6u8, 0xDBu8,
+        0x86u8, 0x6Bu8, 0x29u8, 0x40u8, 0x71u8, 0xA8u8, 0x37u8, 0x1Du8, 0xE4u8, 0x56u8, 0xE6u8,
+        0x3Fu8, 0x6Bu8, 0xA0u8, 0x8Au8, 0x7Du8, 0xADu8, 0x1Au8, 0x92u8, 0xBFu8, 0xE0u8, 0xA4u8,
+        0xD6u8, 0xC0u8, 0x86u8, 0x30u8, 0x77u8, 0xBFu8, 0x3Cu8, 0x75u8, 0xC0u8, 0x52u8, 0x88u8,
+        0x53u8, 0x37u8, 0xBFu8, 0xC0u8, 0x7Au8, 0xEDu8, 0x35u8, 0x8Cu8, 0x5Bu8, 0xDEu8, 0x3Eu8,
+        0x09u8, 0xB1u8, 0xBCu8, 0x74u8, 0x49u8, 0x4Du8, 0xC9u8, 0x3Eu8, 0x12u8, 0x94u8, 0xB3u8,
+        0xC5u8, 0xC9u8, 0x40u8, 0x8Cu8, 0x3Eu8, 0x00u8, 0x00u8, 0x00u8, 0x16u8, 0x50u8, 0x70u8,
+        0x0Au8, 0xC2u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x18u8, 0x15u8, 0x41u8, 0x72u8,
+        0x89u8, 0xABu8, 0x6Fu8, 0x60u8, 0x31u8, 0x76u8, 0x41u8, 0x96u8, 0x3Cu8, 0xE7u8, 0xC5u8,
+        0x10u8, 0x75u8, 0x70u8, 0xC1u8, 0xF0u8, 0x6Fu8, 0x81u8, 0xF3u8, 0xCDu8, 0x21u8, 0x2Du8,
+        0xC1u8, 0xEAu8, 0x0Fu8, 0x3Fu8, 0xE2u8, 0xDBu8, 0xDEu8, 0xF8u8, 0x40u8, 0x94u8, 0x68u8,
+        0xE4u8, 0x62u8, 0xDDu8, 0x72u8, 0xBAu8, 0x40u8, 0x89u8, 0x2Bu8, 0xEFu8, 0xDDu8, 0x8Eu8,
+        0x45u8, 0x79u8, 0xC0u8, 0x3Eu8, 0xB6u8, 0x45u8, 0x5Du8, 0xAFu8, 0x7Fu8, 0x4Au8, 0xC0u8,
+        0x0Au8, 0x1Bu8, 0xB9u8, 0xA0u8, 0x14u8, 0xE8u8, 0xF5u8, 0x3Fu8, 0xBBu8, 0x90u8, 0x97u8,
+        0x91u8, 0xC6u8, 0x1Cu8, 0xDCu8, 0x3Fu8, 0x23u8, 0x27u8, 0xD8u8, 0x51u8, 0xF1u8, 0x0Eu8,
+        0x5Eu8, 0x3Fu8, 0x72u8, 0xADu8, 0x46u8, 0x4Eu8, 0xB2u8, 0x9Bu8, 0x6Du8, 0xBFu8, 0xA1u8,
+        0x74u8, 0x7Eu8, 0x2Au8, 0x8Bu8, 0x5Fu8, 0x20u8, 0xBFu8, 0x83u8, 0xA0u8, 0x72u8, 0x71u8,
+        0xBCu8, 0xA7u8, 0xFDu8, 0x3Eu8, 0x39u8, 0xD1u8, 0x84u8, 0x8Au8, 0xE2u8, 0xFFu8, 0xC0u8,
+        0x3Eu8, 0x6Au8, 0xBBu8, 0x39u8, 0x7Du8, 0xE8u8, 0x1Fu8, 0x80u8, 0x41u8, 0x30u8, 0xA8u8,
+        0x84u8, 0x63u8, 0x56u8, 0x8Fu8, 0x5Du8, 0x41u8, 0x72u8, 0xC9u8, 0x0Du8, 0xD3u8, 0xCBu8,
+        0x27u8, 0x35u8, 0xC1u8, 0xFDu8, 0xF3u8, 0x40u8, 0x43u8, 0x54u8, 0x5Eu8, 0xF0u8, 0xC0u8,
+        0xC7u8, 0x9Cu8, 0xEEu8, 0x7Du8, 0xC2u8, 0xA1u8, 0xB7u8, 0x40u8, 0xA3u8, 0xC5u8, 0x2Cu8,
+        0x20u8, 0x8Du8, 0xB5u8, 0x7Fu8, 0x40u8, 0x08u8, 0x05u8, 0x9Cu8, 0x55u8, 0xD2u8, 0x89u8,
+        0x38u8, 0xC0u8, 0x83u8, 0x87u8, 0xD0u8, 0x23u8, 0x79u8, 0xE0u8, 0x10u8, 0xC0u8, 0x0Au8,
+        0xCCu8, 0xECu8, 0xF5u8, 0x10u8, 0xB9u8, 0xB0u8, 0x3Fu8, 0x33u8, 0xE9u8, 0x58u8, 0xBDu8,
+        0x7Cu8, 0x3Bu8, 0xA2u8, 0x3Fu8, 0x57u8, 0x49u8, 0x1Fu8, 0xFCu8, 0x38u8, 0xCEu8, 0x40u8,
+        0x3Fu8, 0xE8u8, 0x43u8, 0x1Cu8, 0x7Cu8, 0x37u8, 0x28u8, 0x33u8, 0xBFu8, 0x9Fu8, 0x56u8,
+        0xABu8, 0xC8u8, 0x2Cu8, 0x34u8, 0xECu8, 0xBEu8, 0xC3u8, 0x31u8, 0xC4u8, 0x6Du8, 0x9Au8,
+        0xE4u8, 0xC2u8, 0x3Eu8, 0x43u8, 0x60u8, 0xA7u8, 0xC0u8, 0xE4u8, 0xBFu8, 0x6Du8, 0x41u8,
+        0x6Cu8, 0x5Eu8, 0xEEu8, 0x62u8, 0x4Cu8, 0xAEu8, 0x56u8, 0x41u8, 0x28u8, 0xFEu8, 0xE2u8,
+        0x3Fu8, 0x9Bu8, 0x82u8, 0x23u8, 0xC1u8, 0xE8u8, 0xFDu8, 0x5Fu8, 0x20u8, 0x35u8, 0xAFu8,
+        0xE6u8, 0xC0u8, 0x07u8, 0x5Bu8, 0x15u8, 0x87u8, 0x28u8, 0xA8u8, 0xA3u8, 0x40u8, 0x0Bu8,
+        0xBDu8, 0x44u8, 0x1Du8, 0x2Eu8, 0x91u8, 0x73u8, 0x40u8, 0x37u8, 0x02u8, 0x6Au8, 0xCFu8,
+        0x24u8, 0x19u8, 0x1Eu8, 0xC0u8, 0xD9u8, 0xC1u8, 0xEEu8, 0x2Fu8, 0x83u8, 0x27u8, 0x03u8,
+        0xC0u8, 0xB7u8, 0x22u8, 0xD1u8, 0x35u8, 0xF3u8, 0x16u8, 0x87u8, 0xBFu8, 0x59u8, 0xE7u8,
+        0xFEu8, 0x9Du8, 0xD0u8, 0x40u8, 0x93u8, 0x3Fu8, 0x60u8, 0x2Au8, 0x1Cu8, 0x5Bu8, 0x09u8,
+        0x66u8, 0x45u8, 0x3Fu8, 0xB5u8, 0xEBu8, 0x2Fu8, 0x8Cu8, 0xC6u8, 0xB7u8, 0x22u8, 0xBFu8,
+        0x92u8, 0x1Eu8, 0x72u8, 0x03u8, 0x25u8, 0x45u8, 0xE5u8, 0xBEu8, 0x90u8, 0xFCu8, 0xFCu8,
+        0x77u8, 0xDFu8, 0x94u8, 0xB0u8, 0x3Eu8, 0x00u8, 0x00u8, 0x00u8, 0xB6u8, 0xFBu8, 0x6Fu8,
+        0x0Au8, 0xC2u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x18u8, 0x15u8, 0x41u8, 0xACu8,
+        0xB5u8, 0x4Fu8, 0x0Fu8, 0x74u8, 0x47u8, 0x6Bu8, 0xC1u8, 0x3Fu8, 0x1Eu8, 0x08u8, 0xF9u8,
+        0xBDu8, 0x2Fu8, 0x72u8, 0xC1u8, 0xD3u8, 0x75u8, 0xA7u8, 0x1Cu8, 0x13u8, 0x72u8, 0x1Fu8,
+        0x41u8, 0xDEu8, 0x91u8, 0xCAu8, 0x0Bu8, 0xCBu8, 0xDEu8, 0xFAu8, 0x40u8, 0x6Eu8, 0x5Fu8,
+        0xF2u8, 0x42u8, 0xD3u8, 0xCCu8, 0xB5u8, 0xC0u8, 0xF7u8, 0x4Fu8, 0x5Du8, 0x29u8, 0x82u8,
+        0x23u8, 0x77u8, 0xC0u8, 0x6Cu8, 0x2Du8, 0xF3u8, 0x2Cu8, 0x29u8, 0x6Eu8, 0x48u8, 0x40u8,
+        0x31u8, 0x42u8, 0x74u8, 0xD9u8, 0x0Cu8, 0xFAu8, 0xD5u8, 0x3Fu8, 0x4Eu8, 0xEAu8, 0xCAu8,
+        0x46u8, 0x42u8, 0x9Du8, 0xD7u8, 0xBFu8, 0x89u8, 0x24u8, 0x80u8, 0xF7u8, 0xC2u8, 0x8Au8,
+        0x8Du8, 0x3Fu8, 0xCDu8, 0xC6u8, 0xA9u8, 0x22u8, 0x7Fu8, 0x99u8, 0x62u8, 0x3Fu8, 0x75u8,
+        0xB2u8, 0x2Bu8, 0x12u8, 0x77u8, 0xE9u8, 0x2Du8, 0xBFu8, 0x42u8, 0x49u8, 0xC4u8, 0x33u8,
+        0x41u8, 0x5Bu8, 0xE1u8, 0xBEu8, 0xECu8, 0x50u8, 0x78u8, 0xF7u8, 0xE9u8, 0x2Eu8, 0xC4u8,
+        0x3Eu8, 0x13u8, 0x2Cu8, 0x05u8, 0xC9u8, 0x32u8, 0xB4u8, 0x81u8, 0x41u8, 0xC5u8, 0x13u8,
+        0x90u8, 0xBFu8, 0x36u8, 0x21u8, 0x51u8, 0xC1u8, 0x1Fu8, 0x96u8, 0xC6u8, 0x00u8, 0x84u8,
+        0x26u8, 0x36u8, 0xC1u8, 0xB8u8, 0x09u8, 0x2Au8, 0xD9u8, 0x24u8, 0xCBu8, 0xEAu8, 0x40u8,
+        0x00u8, 0xCAu8, 0x67u8, 0x43u8, 0xEAu8, 0x07u8, 0xB6u8, 0x40u8, 0x43u8, 0xE1u8, 0x56u8,
+        0x06u8, 0x2Eu8, 0xAFu8, 0x7Eu8, 0xC0u8, 0xB0u8, 0xEDu8, 0xD9u8, 0x81u8, 0xAFu8, 0xB0u8,
+        0x2Au8, 0xC0u8, 0xC1u8, 0x0Fu8, 0xBBu8, 0x3Eu8, 0x39u8, 0xF0u8, 0x0Eu8, 0x40u8, 0x3Au8,
+        0x8Eu8, 0x7Eu8, 0x7Eu8, 0x1Eu8, 0xE5u8, 0xB3u8, 0xBFu8, 0x15u8, 0x20u8, 0x1Bu8, 0x11u8,
+        0x9Au8, 0x9Cu8, 0x9Au8, 0xBFu8, 0x10u8, 0xB2u8, 0x7Bu8, 0x58u8, 0xCEu8, 0x3Cu8, 0x5Eu8,
+        0x3Fu8, 0x92u8, 0xD6u8, 0x9Du8, 0x28u8, 0xCAu8, 0x9Au8, 0x20u8, 0x3Fu8, 0xB6u8, 0x58u8,
+        0x14u8, 0x6Fu8, 0xEDu8, 0xDDu8, 0xF6u8, 0xBEu8, 0xECu8, 0xF4u8, 0x8Bu8, 0x35u8, 0x9Bu8,
+        0x3Du8, 0x5Du8, 0xBEu8, 0xD9u8, 0xF8u8, 0x5Eu8, 0x22u8, 0x99u8, 0x52u8, 0x74u8, 0x41u8,
+        0x1Fu8, 0x2Eu8, 0x00u8, 0xFCu8, 0x45u8, 0xF5u8, 0x17u8, 0xC1u8, 0xB7u8, 0x33u8, 0xD7u8,
+        0x28u8, 0xF2u8, 0x47u8, 0x29u8, 0xC1u8, 0x40u8, 0x3Cu8, 0x29u8, 0xB7u8, 0x84u8, 0x4Cu8,
+        0xD1u8, 0x40u8, 0xD4u8, 0x3Eu8, 0xBEu8, 0xAAu8, 0x94u8, 0x14u8, 0xACu8, 0x40u8, 0xCBu8,
+        0x46u8, 0xF2u8, 0xDAu8, 0x1Fu8, 0xE0u8, 0x6Bu8, 0xC0u8, 0xF2u8, 0xB4u8, 0x52u8, 0x94u8,
+        0x1Du8, 0x7Fu8, 0x28u8, 0xC0u8, 0xF7u8, 0x26u8, 0x9Bu8, 0x22u8, 0xD7u8, 0x36u8, 0x00u8,
+        0x40u8, 0xA5u8, 0x84u8, 0x3Au8, 0xDFu8, 0x2Au8, 0x3Cu8, 0x66u8, 0xBFu8, 0x85u8, 0x55u8,
+        0x98u8, 0x61u8, 0xC2u8, 0x7Du8, 0x8Fu8, 0xBFu8, 0x0Fu8, 0x03u8, 0xF3u8, 0xBFu8, 0x43u8,
+        0x72u8, 0x48u8, 0x3Fu8, 0xF0u8, 0x78u8, 0xFBu8, 0xF9u8, 0xB5u8, 0xFEu8, 0x17u8, 0x3Fu8,
+        0x73u8, 0x3Cu8, 0x2Au8, 0xFBu8, 0xBAu8, 0x91u8, 0xE6u8, 0xBEu8, 0x5Du8, 0x41u8, 0x67u8,
+        0xD7u8, 0xDDu8, 0xEEu8, 0x91u8, 0xBEu8, 0x00u8, 0x00u8, 0x00u8, 0x56u8, 0xA7u8, 0x6Fu8,
+        0x0Au8, 0xC2u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x18u8, 0x15u8, 0x41u8, 0x7Du8,
+        0x12u8, 0x5Au8, 0x41u8, 0xEEu8, 0x9Fu8, 0x85u8, 0xC1u8, 0x90u8, 0x7Du8, 0x1Fu8, 0xB6u8,
+        0x46u8, 0xB6u8, 0x65u8, 0xC1u8, 0x8Cu8, 0xAEu8, 0xA7u8, 0xA3u8, 0x95u8, 0xCDu8, 0x32u8,
+        0x41u8, 0xCBu8, 0x8Au8, 0x8Fu8, 0xA5u8, 0xA9u8, 0xC7u8, 0xC9u8, 0x40u8, 0x13u8, 0x49u8,
+        0x2Eu8, 0xF9u8, 0x31u8, 0x91u8, 0xB1u8, 0xC0u8, 0x24u8, 0xD7u8, 0x4Au8, 0x25u8, 0x0Eu8,
+        0xFCu8, 0x6Fu8, 0x40u8, 0x81u8, 0x1Au8, 0x0Au8, 0x20u8, 0x70u8, 0xF4u8, 0xE9u8, 0xBFu8,
+        0x44u8, 0xB7u8, 0x30u8, 0xB3u8, 0xDCu8, 0xC7u8, 0xF2u8, 0xBFu8, 0xBCu8, 0x1Bu8, 0x8Du8,
+        0x96u8, 0x49u8, 0x6Fu8, 0xBAu8, 0x3Fu8, 0x22u8, 0x9Eu8, 0xADu8, 0xB8u8, 0xFAu8, 0x7Fu8,
+        0x64u8, 0xBFu8, 0x5Au8, 0x4Cu8, 0xAAu8, 0x33u8, 0x3Eu8, 0x5Du8, 0x38u8, 0xBFu8, 0xD1u8,
+        0x34u8, 0x32u8, 0x5Bu8, 0x51u8, 0x50u8, 0x09u8, 0x3Fu8, 0xE2u8, 0x2Cu8, 0xE1u8, 0xD2u8,
+        0x92u8, 0xBEu8, 0xC1u8, 0xBEu8, 0x22u8, 0x12u8, 0xE9u8, 0xF6u8, 0x0Fu8, 0xA0u8, 0x7Cu8,
+        0xBEu8, 0x0Cu8, 0xB4u8, 0xC7u8, 0x4Du8, 0x8Eu8, 0x55u8, 0x72u8, 0x41u8, 0xB7u8, 0x90u8,
+        0x05u8, 0xC5u8, 0x0Fu8, 0x23u8, 0x68u8, 0xC1u8, 0xC6u8, 0xA0u8, 0x3Eu8, 0x4Eu8, 0x02u8,
+        0x00u8, 0x21u8, 0xC1u8, 0x3Au8, 0xE8u8, 0xE7u8, 0x00u8, 0xB2u8, 0x59u8, 0xF2u8, 0x40u8,
+        0x5Au8, 0xCEu8, 0xF9u8, 0xF4u8, 0x40u8, 0xF3u8, 0x9Bu8, 0xC0u8, 0x7Fu8, 0x5Bu8, 0xEAu8,
+        0x31u8, 0x91u8, 0x2Du8, 0x61u8, 0xC0u8, 0x13u8, 0xABu8, 0x4Cu8, 0xF7u8, 0x0Fu8, 0x80u8,
+        0x32u8, 0x40u8, 0x2Eu8, 0x61u8, 0xF6u8, 0x67u8, 0x69u8, 0x34u8, 0xEBu8, 0xBFu8, 0xAEu8,
+        0x12u8, 0xE3u8, 0x73u8, 0xBAu8, 0xC9u8, 0x98u8, 0xBFu8, 0xC5u8, 0xFCu8, 0xFCu8, 0x69u8,
+        0x48u8, 0xB4u8, 0x7Bu8, 0x3Fu8, 0x64u8, 0x4Du8, 0x8Cu8, 0xB7u8, 0x62u8, 0x14u8, 0x3Eu8,
+        0xBFu8, 0x21u8, 0x59u8, 0xB2u8, 0x38u8, 0x51u8, 0x4Bu8, 0xB1u8, 0x3Eu8, 0x8Eu8, 0x7Bu8,
+        0xB1u8, 0xB3u8, 0xDAu8, 0xC4u8, 0xC6u8, 0x3Eu8, 0xA9u8, 0x79u8, 0x74u8, 0x8Du8, 0x87u8,
+        0x3Bu8, 0x91u8, 0xBEu8, 0x12u8, 0xB0u8, 0x21u8, 0xF7u8, 0x8Du8, 0xA6u8, 0x6Cu8, 0x41u8,
+        0xF9u8, 0x4Du8, 0x4Du8, 0x31u8, 0x39u8, 0x30u8, 0x55u8, 0xC1u8, 0x21u8, 0xC9u8, 0x8Bu8,
+        0x1Fu8, 0x4Fu8, 0x08u8, 0x1Au8, 0xC1u8, 0x7Au8, 0xA8u8, 0x3Du8, 0x6Eu8, 0x4Eu8, 0xE6u8,
+        0xE2u8, 0x40u8, 0xDCu8, 0x2Du8, 0xD1u8, 0x6Du8, 0xD9u8, 0x1Fu8, 0x7Eu8, 0xC0u8, 0xF8u8,
+        0x25u8, 0x94u8, 0x5Cu8, 0xB3u8, 0x0Au8, 0x59u8, 0xC0u8, 0xF3u8, 0x46u8, 0xD8u8, 0x02u8,
+        0x11u8, 0xE8u8, 0x23u8, 0x40u8, 0xBBu8, 0x3Du8, 0x23u8, 0x62u8, 0x91u8, 0x22u8, 0xD5u8,
+        0xBFu8, 0x66u8, 0x24u8, 0x55u8, 0xF5u8, 0xE4u8, 0x52u8, 0x98u8, 0xBFu8, 0xD6u8, 0x57u8,
+        0xE7u8, 0x6Fu8, 0x1Du8, 0xB5u8, 0x6Fu8, 0x3Fu8, 0xF1u8, 0x95u8, 0xE5u8, 0x93u8, 0x05u8,
+        0xF9u8, 0x2Au8, 0xBFu8, 0x80u8, 0x43u8, 0x74u8, 0xCCu8, 0xACu8, 0xF4u8, 0xD2u8, 0xBEu8,
+        0x76u8, 0x14u8, 0xEFu8, 0xE5u8, 0x68u8, 0x02u8, 0xBCu8, 0x3Eu8, 0xDFu8, 0x1Cu8, 0x87u8,
+        0xFBu8, 0x69u8, 0xD5u8, 0x80u8, 0xBEu8, 0x00u8, 0x00u8, 0x00u8, 0xF6u8, 0x52u8, 0x6Fu8,
+        0x0Au8, 0xC2u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x18u8, 0x15u8, 0x41u8, 0x09u8,
+        0xD1u8, 0xC7u8, 0x51u8, 0x97u8, 0xD7u8, 0x8Bu8, 0xC1u8, 0x88u8, 0x95u8, 0xEEu8, 0x9Au8,
+        0xA6u8, 0xF2u8, 0x3Au8, 0xC1u8, 0xACu8, 0xFFu8, 0xECu8, 0x74u8, 0x71u8, 0xE3u8, 0x30u8,
+        0x41u8, 0x06u8, 0x5Fu8, 0x0Bu8, 0xEAu8, 0x40u8, 0x3Cu8, 0xD8u8, 0xC0u8, 0x95u8, 0x74u8,
+        0x21u8, 0x8Fu8, 0x9Bu8, 0x0Fu8, 0x89u8, 0xC0u8, 0xF5u8, 0x5Fu8, 0x48u8, 0x3Du8, 0xF6u8,
+        0xA3u8, 0x58u8, 0x40u8, 0x91u8, 0x52u8, 0x21u8, 0x17u8, 0xB7u8, 0xE6u8, 0x18u8, 0xC0u8,
+        0x5Eu8, 0x9Cu8, 0xB1u8, 0x33u8, 0x8Fu8, 0xBAu8, 0xCBu8, 0x3Fu8, 0xF3u8, 0x81u8, 0xE6u8,
+        0x3Du8, 0x68u8, 0xF6u8, 0x58u8, 0x3Fu8, 0xE4u8, 0xA3u8, 0x27u8, 0x43u8, 0x27u8, 0xFFu8,
+        0x4Du8, 0xBFu8, 0x4Au8, 0x21u8, 0x44u8, 0xFAu8, 0xCEu8, 0xCCu8, 0x14u8, 0x3Fu8, 0x3Du8,
+        0xF9u8, 0xA8u8, 0x5Au8, 0x00u8, 0xA0u8, 0xD0u8, 0xBEu8, 0x21u8, 0x27u8, 0x64u8, 0xD2u8,
+        0x31u8, 0x15u8, 0x71u8, 0x3Eu8, 0xABu8, 0x74u8, 0x92u8, 0xCFu8, 0x24u8, 0xA5u8, 0x44u8,
+        0x3Eu8, 0x0Cu8, 0x6Au8, 0x98u8, 0x95u8, 0x10u8, 0xDEu8, 0x5Eu8, 0xC1u8, 0x62u8, 0x69u8,
+        0xE3u8, 0xB4u8, 0xF6u8, 0xDBu8, 0x6Au8, 0xC1u8, 0xB7u8, 0xDBu8, 0x0Bu8, 0xB3u8, 0xD6u8,
+        0xF1u8, 0x00u8, 0x41u8, 0xA3u8, 0x87u8, 0x4Cu8, 0x0Eu8, 0x82u8, 0xEEu8, 0xE3u8, 0x40u8,
+        0xF2u8, 0x88u8, 0xC6u8, 0xA9u8, 0xAEu8, 0xE0u8, 0x9Du8, 0xC0u8, 0xB1u8, 0x0Du8, 0xC4u8,
+        0x0Du8, 0x20u8, 0x7Fu8, 0x4Bu8, 0x40u8, 0x2Eu8, 0xB7u8, 0x95u8, 0x6Bu8, 0xE9u8, 0x1Au8,
+        0xECu8, 0x3Fu8, 0xB0u8, 0x33u8, 0x83u8, 0xCAu8, 0x02u8, 0xD2u8, 0xCFu8, 0xBFu8, 0x04u8,
+        0x39u8, 0xE6u8, 0x32u8, 0x2Cu8, 0x75u8, 0x93u8, 0x3Fu8, 0x3Eu8, 0xCCu8, 0x12u8, 0x03u8,
+        0x1Au8, 0xD1u8, 0x4Bu8, 0xBFu8, 0xC0u8, 0x0Bu8, 0xD3u8, 0x23u8, 0x32u8, 0xE7u8, 0xE0u8,
+        0x3Eu8, 0x50u8, 0x54u8, 0x54u8, 0xCBu8, 0xA9u8, 0x09u8, 0xC5u8, 0x3Eu8, 0x6Eu8, 0xE2u8,
+        0x04u8, 0xCEu8, 0x38u8, 0x48u8, 0x92u8, 0xBEu8, 0xC5u8, 0xF7u8, 0x58u8, 0x81u8, 0xF0u8,
+        0x1Du8, 0x51u8, 0x3Eu8, 0x17u8, 0xAFu8, 0xE1u8, 0x34u8, 0x0Cu8, 0xC7u8, 0x3Bu8, 0x41u8,
+        0x65u8, 0xEAu8, 0xCBu8, 0x32u8, 0xC2u8, 0xF1u8, 0x5Bu8, 0xC1u8, 0x29u8, 0x9Au8, 0x8Eu8,
+        0xE6u8, 0x69u8, 0x96u8, 0xE4u8, 0xC0u8, 0xE2u8, 0x97u8, 0x8Fu8, 0xAAu8, 0xCAu8, 0xCEu8,
+        0xD7u8, 0x40u8, 0xE0u8, 0xC7u8, 0x41u8, 0x3Du8, 0x12u8, 0x3Eu8, 0x8Du8, 0xC0u8, 0x9Cu8,
+        0x55u8, 0xBAu8, 0x9Eu8, 0x38u8, 0xFCu8, 0x32u8, 0x40u8, 0x70u8, 0x88u8, 0xC6u8, 0x1Eu8,
+        0x0Au8, 0xF4u8, 0xF1u8, 0x3Fu8, 0xD3u8, 0x9Bu8, 0x89u8, 0xEDu8, 0x58u8, 0xE2u8, 0xC3u8,
+        0xBFu8, 0xC1u8, 0x38u8, 0x3Du8, 0x45u8, 0x11u8, 0x6Eu8, 0x84u8, 0x3Fu8, 0x3Au8, 0x68u8,
+        0x2Eu8, 0x42u8, 0xA7u8, 0x60u8, 0x37u8, 0xBFu8, 0xA7u8, 0x75u8, 0x1Au8, 0x58u8, 0x5Du8,
+        0xE7u8, 0xD0u8, 0xBEu8, 0xAAu8, 0xDEu8, 0xDDu8, 0xDBu8, 0x90u8, 0x6Du8, 0xBDu8, 0x3Eu8,
+        0xEAu8, 0x8Bu8, 0x5Fu8, 0xD1u8, 0x93u8, 0x65u8, 0x84u8, 0xBEu8, 0xCAu8, 0xCAu8, 0xAFu8,
+        0xC9u8, 0x05u8, 0x63u8, 0x40u8, 0x3Eu8, 0x00u8, 0x00u8, 0x00u8, 0x96u8, 0xFEu8, 0x6Eu8,
+        0x0Au8, 0xC2u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x18u8, 0x15u8, 0x41u8, 0xCCu8,
+        0xFCu8, 0x58u8, 0x50u8, 0x14u8, 0xCBu8, 0x89u8, 0xC1u8, 0xF0u8, 0x25u8, 0x26u8, 0xEFu8,
+        0x42u8, 0x12u8, 0x56u8, 0x41u8, 0x93u8, 0x30u8, 0x49u8, 0x50u8, 0x60u8, 0xAFu8, 0x27u8,
+        0x41u8, 0x8Du8, 0x11u8, 0x2Bu8, 0x1Du8, 0xBAu8, 0x68u8, 0xDBu8, 0xC0u8, 0x88u8, 0x74u8,
+        0xB4u8, 0xDAu8, 0x9Fu8, 0xA6u8, 0x5Eu8, 0x40u8, 0x10u8, 0x5Eu8, 0x90u8, 0xC8u8, 0x63u8,
+        0xDDu8, 0x27u8, 0x40u8, 0xAAu8, 0x49u8, 0xB8u8, 0x60u8, 0x10u8, 0x4Bu8, 0xFAu8, 0xBFu8,
+        0x66u8, 0xFAu8, 0xBCu8, 0x1Bu8, 0x22u8, 0x3Bu8, 0xB7u8, 0x3Fu8, 0x3Au8, 0x51u8, 0x0Fu8,
+        0x0Fu8, 0x3Cu8, 0x3Eu8, 0x70u8, 0xBFu8, 0x51u8, 0xF7u8, 0x56u8, 0x23u8, 0xBDu8, 0x16u8,
+        0x1Du8, 0x3Fu8, 0xBFu8, 0x0Au8, 0x72u8, 0x9Eu8, 0x02u8, 0xF9u8, 0x91u8, 0x3Eu8, 0x88u8,
+        0xA1u8, 0x28u8, 0x8Du8, 0x30u8, 0x63u8, 0x94u8, 0xBEu8, 0x57u8, 0xBCu8, 0x60u8, 0x6Fu8,
+        0xDFu8, 0x45u8, 0x5Cu8, 0x3Eu8, 0x93u8, 0xB5u8, 0x7Fu8, 0x44u8, 0xDAu8, 0x4Cu8, 0x13u8,
+        0xBEu8, 0x44u8, 0x74u8, 0x33u8, 0x8Cu8, 0xF0u8, 0x2Au8, 0x80u8, 0xC1u8, 0x5Au8, 0x20u8,
+        0x66u8, 0x25u8, 0x5Cu8, 0xD6u8, 0x65u8, 0xC1u8, 0xE8u8, 0x91u8, 0xFEu8, 0xB0u8, 0x02u8,
+        0x5Au8, 0x1Du8, 0x41u8, 0x8Eu8, 0x58u8, 0x45u8, 0x41u8, 0x6Du8, 0x48u8, 0xD2u8, 0x40u8,
+        0xADu8, 0xE8u8, 0xB7u8, 0x2Du8, 0x40u8, 0x8Au8, 0x8Cu8, 0xC0u8, 0xC8u8, 0x56u8, 0x1Du8,
+        0x53u8, 0x36u8, 0xDFu8, 0x42u8, 0x40u8, 0x34u8, 0x27u8, 0x42u8, 0x07u8, 0xF9u8, 0x19u8,
+        0xF3u8, 0xBFu8, 0x85u8, 0xC3u8, 0x85u8, 0x0Au8, 0x62u8, 0xBFu8, 0x84u8, 0x3Fu8, 0xEDu8,
+        0xFBu8, 0x6Bu8, 0x5Au8, 0xABu8, 0xEBu8, 0x59u8, 0x3Fu8, 0xE6u8, 0xB7u8, 0xCAu8, 0x68u8,
+        0xA0u8, 0x55u8, 0x25u8, 0xBFu8, 0x74u8, 0x7Bu8, 0xE0u8, 0x18u8, 0xB8u8, 0x37u8, 0xE4u8,
+        0x3Eu8, 0x15u8, 0xE0u8, 0x40u8, 0x07u8, 0x32u8, 0x5Bu8, 0x9Cu8, 0xBEu8, 0x7Cu8, 0x83u8,
+        0xCCu8, 0x0Eu8, 0x38u8, 0xB0u8, 0x47u8, 0x3Eu8, 0xD2u8, 0x04u8, 0xC6u8, 0x52u8, 0xCAu8,
+        0xC8u8, 0x03u8, 0x3Eu8, 0x7Cu8, 0xA2u8, 0x5Cu8, 0x95u8, 0x4Fu8, 0xA6u8, 0x67u8, 0xC1u8,
+        0xD7u8, 0x42u8, 0x72u8, 0x88u8, 0x93u8, 0x9Cu8, 0x59u8, 0xC1u8, 0xA2u8, 0x3Eu8, 0x2Eu8,
+        0x45u8, 0x93u8, 0x5Du8, 0x05u8, 0x41u8, 0xCDu8, 0xB1u8, 0x4Bu8, 0x4Du8, 0x85u8, 0x42u8,
+        0xC9u8, 0x40u8, 0x5Eu8, 0x07u8, 0x89u8, 0x36u8, 0x53u8, 0x40u8, 0x7Fu8, 0xC0u8, 0x38u8,
+        0x41u8, 0x31u8, 0xC2u8, 0x3Eu8, 0xE1u8, 0x32u8, 0x40u8, 0x2Cu8, 0xACu8, 0x79u8, 0xE0u8,
+        0x6Eu8, 0xB6u8, 0xDDu8, 0xBFu8, 0x4Du8, 0xAAu8, 0xBFu8, 0xC0u8, 0x84u8, 0xE4u8, 0x70u8,
+        0xBFu8, 0x88u8, 0x30u8, 0x3Fu8, 0xC6u8, 0xDDu8, 0xA5u8, 0x54u8, 0x3Fu8, 0x3Du8, 0x17u8,
+        0xDBu8, 0xD9u8, 0x2Cu8, 0xD0u8, 0x19u8, 0xBFu8, 0x93u8, 0xC0u8, 0x0Du8, 0x5Fu8, 0xE9u8,
+        0x72u8, 0xD5u8, 0x3Eu8, 0x05u8, 0x18u8, 0x1Bu8, 0xDFu8, 0x6Eu8, 0xF8u8, 0x89u8, 0xBEu8,
+        0x52u8, 0x40u8, 0xCCu8, 0xBCu8, 0x3Bu8, 0xA6u8, 0x2Bu8, 0x3Eu8, 0x84u8, 0x49u8, 0xFFu8,
+        0xA4u8, 0xC9u8, 0x91u8, 0xEAu8, 0x3Du8, 0x00u8, 0x00u8, 0x00u8, 0x36u8, 0xAAu8, 0x6Eu8,
+        0x0Au8, 0xC2u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x18u8, 0x15u8, 0x41u8, 0x80u8,
+        0x70u8, 0xA5u8, 0xA8u8, 0x44u8, 0xCFu8, 0x81u8, 0xC1u8, 0x37u8, 0x9Cu8, 0xD6u8, 0x64u8,
+        0x00u8, 0x63u8, 0x64u8, 0x41u8, 0xDFu8, 0xC0u8, 0xBAu8, 0x58u8, 0x6Cu8, 0xB3u8, 0x1Bu8,
+        0x41u8, 0x6Cu8, 0x64u8, 0x69u8, 0x85u8, 0x0Eu8, 0x16u8, 0xD9u8, 0xC0u8, 0xDFu8, 0xC2u8,
+        0xE8u8, 0x32u8, 0x9Cu8, 0x4Fu8, 0x5Cu8, 0x40u8, 0x60u8, 0xE3u8, 0x4Fu8, 0x41u8, 0xEEu8,
+        0xD4u8, 0x1Fu8, 0xC0u8, 0xC9u8, 0x5Du8, 0x19u8, 0xEDu8, 0x0Bu8, 0xF8u8, 0xD5u8, 0xBFu8,
+        0x10u8, 0x2Du8, 0x31u8, 0xEBu8, 0xBEu8, 0xF8u8, 0x91u8, 0x3Fu8, 0x30u8, 0xCBu8, 0x24u8,
+        0x66u8, 0xB5u8, 0x27u8, 0x51u8, 0xBFu8, 0xB0u8, 0x88u8, 0xBBu8, 0x07u8, 0x83u8, 0x8Du8,
+        0x07u8, 0x3Fu8, 0xE0u8, 0x8Eu8, 0x56u8, 0x4Du8, 0xF5u8, 0x1Du8, 0xB8u8, 0xBEu8, 0x97u8,
+        0xE4u8, 0x99u8, 0x90u8, 0x42u8, 0x3Bu8, 0x66u8, 0x3Eu8, 0xACu8, 0x3Bu8, 0x67u8, 0x0Fu8,
+        0x24u8, 0xDEu8, 0xF2u8, 0x3Du8, 0xE2u8, 0x5Au8, 0x49u8, 0x2Au8, 0xABu8, 0xBCu8, 0xD6u8,
+        0xBDu8, 0xB0u8, 0xDDu8, 0x74u8, 0xB1u8, 0x29u8, 0xFBu8, 0x88u8, 0xC1u8, 0x23u8, 0xF3u8,
+        0xACu8, 0xAFu8, 0xDFu8, 0x55u8, 0x5Au8, 0xC1u8, 0xC2u8, 0xFFu8, 0xB6u8, 0x1Fu8, 0x8Fu8,
+        0x79u8, 0x23u8, 0x41u8, 0x19u8, 0x85u8, 0x6Bu8, 0x62u8, 0xD0u8, 0x12u8, 0xC1u8, 0x40u8,
+        0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x00u8, 0x00u8, 0x18u8, 0x25u8, 0x41u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8,
+        0x46u8, 0x40u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x2Cu8, 0x40u8,
+    ];
+}
diff --git a/crates/lox_core/src/lib.rs b/crates/lox_core/src/lib.rs
index 97efaf5a..bbedc7ba 100644
--- a/crates/lox_core/src/lib.rs
+++ b/crates/lox_core/src/lib.rs
@@ -8,6 +8,7 @@
 
 pub mod bodies;
 pub mod communications;
+pub mod ephemeris;
 pub mod errors;
 pub mod frames;
 pub mod time;