1 // Copyright 2021, The Android Open Source Project
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 //! This module provides `ResidentHal`, an implementation of a IDiceDevice HAL Interface.
16 //! While the name implies that the DICE secrets are memory resident, the residency
17 //! is augmented by the implementation of the traits `DiceArtifacts` and
18 //! `UpdatableDiceArtifacts`. The implementation outsources all operations that
19 //! involve the DICE secrets to a short lived child process. By implementing
20 //! `UpdatableDiceArtifacts` accordingly, integrators can limit the exposure of
21 //! the resident DICE secrets to user space memory. E.g., an implementation might only
22 //! hold a path to a securefs file allowing the child to read and update the kernel state
23 //! through this path directly.
24 //!
25 //! ## Important Safety Note.
26 //! The module is not safe to use in multi threaded processes. It uses fork and runs
27 //! code that is not async signal safe in the child. Implementing a HAL service without
28 //! starting a thread pool is safe, but no secondary thread must be created.
29
30 use crate::error_vendor::map_or_log_err;
31 use android_hardware_security_dice::aidl::android::hardware::security::dice::{
32 Bcc::Bcc, BccHandover::BccHandover, IDiceDevice::BnDiceDevice, IDiceDevice::IDiceDevice,
33 InputValues::InputValues as BinderInputValues, Signature::Signature,
34 };
35 use anyhow::{Context, Result};
36 use binder::{BinderFeatures, Result as BinderResult, Strong};
37 use dice::{ContextImpl, OpenDiceCborContext};
38 use diced_open_dice_cbor as dice;
39 use diced_utils as utils;
40 use nix::sys::wait::{waitpid, WaitStatus};
41 use nix::unistd::{
42 close, fork, pipe as nix_pipe, read as nix_read, write as nix_write, ForkResult,
43 };
44 use serde::{de::DeserializeOwned, Deserialize, Serialize};
45 use std::convert::TryInto;
46 use std::io::{Read, Write};
47 use std::os::unix::io::RawFd;
48 use std::sync::{Arc, RwLock};
49 use utils::ResidentArtifacts;
50 pub use utils::{DiceArtifacts, UpdatableDiceArtifacts};
51
52 /// PipeReader is a simple wrapper around raw pipe file descriptors.
53 /// It takes ownership of the file descriptor and closes it on drop. It provides `read_all`, which
54 /// reads from the pipe into an expending vector, until no more data can be read.
55 struct PipeReader(RawFd);
56
57 impl Read for PipeReader {
read(&mut self, buf: &mut [u8]) -> std::io::Result<usize>58 fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
59 let bytes = nix_read(self.0, buf)?;
60 Ok(bytes)
61 }
62 }
63
64 impl Drop for PipeReader {
drop(&mut self)65 fn drop(&mut self) {
66 close(self.0).expect("Failed to close reader pipe fd.");
67 }
68 }
69
70 /// PipeWriter is a simple wrapper around raw pipe file descriptors.
71 /// It takes ownership of the file descriptor and closes it on drop. It provides `write`, which
72 /// writes the given buffer into the pipe, returning the number of bytes written.
73 struct PipeWriter(RawFd);
74
75 impl Write for PipeWriter {
write(&mut self, buf: &[u8]) -> std::io::Result<usize>76 fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
77 let written = nix_write(self.0, buf)?;
78 Ok(written)
79 }
80
flush(&mut self) -> std::io::Result<()>81 fn flush(&mut self) -> std::io::Result<()> {
82 // Flush is a NO-OP.
83 Ok(())
84 }
85 }
86
87 impl Drop for PipeWriter {
drop(&mut self)88 fn drop(&mut self) {
89 close(self.0).expect("Failed to close writer pipe fd.");
90 }
91 }
92
pipe() -> Result<(PipeReader, PipeWriter), nix::Error>93 fn pipe() -> Result<(PipeReader, PipeWriter), nix::Error> {
94 let (read_fd, write_fd) = nix_pipe()?;
95 Ok((PipeReader(read_fd), PipeWriter(write_fd)))
96 }
97
98 #[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, thiserror::Error)]
99 enum RunForkedError {
100 #[error("RunForkedError::String({0:?})")]
101 String(String),
102 }
103
104 /// Run the given closure in a new process.
105 /// Safety: The function runs code that is not async-signal-safe in the child after forking.
106 /// This means, that this function must not be called by a multi threaded process.
run_forked<F, R>(f: F) -> Result<R> where R: Serialize + DeserializeOwned, F: FnOnce() -> Result<R>,107 fn run_forked<F, R>(f: F) -> Result<R>
108 where
109 R: Serialize + DeserializeOwned,
110 F: FnOnce() -> Result<R>,
111 {
112 let (reader, writer) = pipe().expect("Failed to create pipe.");
113
114 match unsafe { fork() } {
115 Ok(ForkResult::Parent { child, .. }) => {
116 drop(writer);
117 let status = waitpid(child, None).expect("Failed while waiting for child.");
118 if let WaitStatus::Exited(_, 0) = status {
119 // Child exited successfully.
120 // Read the result from the pipe.
121 // Deserialize the result and return it.
122 let result: Result<R, RunForkedError> =
123 serde_cbor::from_reader(reader).expect("Failed to deserialize result.");
124
125 result.context("In run_forked:")
126 } else {
127 panic!("Child did not exit as expected {:?}", status);
128 }
129 }
130 Ok(ForkResult::Child) => {
131 // Run the closure.
132 let result = f()
133 .map_err(|err| RunForkedError::String(format! {"Nested anyhow error {:?}", err}));
134
135 // Serialize the result of the closure.
136 serde_cbor::to_writer(writer, &result).expect("Result serialization failed");
137
138 // Set exit status to `0`.
139 std::process::exit(0);
140 }
141 Err(errno) => {
142 panic!("Failed to fork: {:?}", errno);
143 }
144 }
145 }
146
147 /// A DiceHal backend implementation.
148 /// All functions, except `demote`, derive effective dice artifacts starting from
149 /// this node and iterating through `input_values` in ascending order.
150 pub trait DiceHalImpl {
151 /// Signs the message using the effective dice artifacts and Ed25519Pure.
sign(&self, input_values: &[BinderInputValues], message: &[u8]) -> Result<Signature>152 fn sign(&self, input_values: &[BinderInputValues], message: &[u8]) -> Result<Signature>;
153 /// Returns the effective attestation chain.
get_attestation_chain(&self, input_values: &[BinderInputValues]) -> Result<Bcc>154 fn get_attestation_chain(&self, input_values: &[BinderInputValues]) -> Result<Bcc>;
155 /// Returns the effective dice artifacts.
derive(&self, input_values: &[BinderInputValues]) -> Result<BccHandover>156 fn derive(&self, input_values: &[BinderInputValues]) -> Result<BccHandover>;
157 /// This demotes the implementation itself. I.e. a resident node would replace its resident
158 /// artifacts with the effective artifacts derived using `input_values`. A proxy node would
159 /// simply call `demote` on its parent node. This is not reversible and changes
160 /// the effective dice artifacts of all clients.
demote(&self, input_values: &[BinderInputValues]) -> Result<()>161 fn demote(&self, input_values: &[BinderInputValues]) -> Result<()>;
162 }
163
164 /// The ResidentHal implements a IDiceDevice backend with memory resident DICE secrets.
165 pub struct ResidentHal<T: UpdatableDiceArtifacts + Serialize + DeserializeOwned + Clone + Send> {
166 artifacts: RwLock<T>,
167 }
168
169 impl<T: UpdatableDiceArtifacts + Serialize + DeserializeOwned + Clone + Send> ResidentHal<T> {
170 /// Creates a new Resident node with the given dice secrets and certificate chain.
171 /// ## Safety
172 /// It is not safe to use implementations of ResidentHal in multi threaded environments.
173 /// If using this library to implement a HAL service make sure not to start a thread pool.
new(artifacts: T) -> Result<Self>174 pub unsafe fn new(artifacts: T) -> Result<Self> {
175 Ok(ResidentHal { artifacts: RwLock::new(artifacts) })
176 }
177
with_effective_artifacts<R, F>(&self, input_values: &[BinderInputValues], f: F) -> Result<R> where R: Serialize + DeserializeOwned, F: FnOnce(ResidentArtifacts) -> Result<R>,178 fn with_effective_artifacts<R, F>(&self, input_values: &[BinderInputValues], f: F) -> Result<R>
179 where
180 R: Serialize + DeserializeOwned,
181 F: FnOnce(ResidentArtifacts) -> Result<R>,
182 {
183 let artifacts = self.artifacts.read().unwrap().clone();
184
185 // Safety: run_forked must not be be called by a multi threaded process.
186 // This requirement is propagated to the public interface of this module through
187 // `ResidentHal::new`
188 run_forked(move || {
189 let artifacts = artifacts.with_artifacts(|a| ResidentArtifacts::new_from(a))?;
190 let input_values: Vec<utils::InputValues> =
191 input_values.iter().map(|v| v.into()).collect();
192 let artifacts = artifacts
193 .execute_steps(input_values.iter().map(|v| v as &dyn dice::InputValues))
194 .context("In ResidentHal::get_effective_artifacts:")?;
195 f(artifacts)
196 })
197 }
198 }
199
200 impl<T: UpdatableDiceArtifacts + Serialize + DeserializeOwned + Clone + Send> DiceHalImpl
201 for ResidentHal<T>
202 {
sign(&self, input_values: &[BinderInputValues], message: &[u8]) -> Result<Signature>203 fn sign(&self, input_values: &[BinderInputValues], message: &[u8]) -> Result<Signature> {
204 let signature: Vec<u8> = self
205 .with_effective_artifacts(input_values, |artifacts| {
206 let (cdi_attest, _, _) = artifacts.into_tuple();
207 let mut dice = OpenDiceCborContext::new();
208 let seed = dice
209 .derive_cdi_private_key_seed(cdi_attest[..].try_into().with_context(|| {
210 format!(
211 "In ResidentHal::sign: Failed to convert cdi_attest (length: {}).",
212 cdi_attest.len()
213 )
214 })?)
215 .context("In ResidentHal::sign: Failed to derive seed from cdi_attest.")?;
216 let (_public_key, private_key) = dice
217 .keypair_from_seed(seed[..].try_into().with_context(|| {
218 format!(
219 "In ResidentHal::sign: Failed to convert seed (length: {}).",
220 seed.len()
221 )
222 })?)
223 .context("In ResidentHal::sign: Failed to derive keypair from seed.")?;
224 dice.sign(
225 message,
226 private_key[..].try_into().with_context(|| {
227 format!(
228 "In ResidentHal::sign: Failed to convert private_key (length: {}).",
229 private_key.len()
230 )
231 })?,
232 )
233 .context("In ResidentHal::sign: Failed to sign.")
234 })
235 .context("In ResidentHal::sign:")?;
236 Ok(Signature { data: signature })
237 }
238
get_attestation_chain(&self, input_values: &[BinderInputValues]) -> Result<Bcc>239 fn get_attestation_chain(&self, input_values: &[BinderInputValues]) -> Result<Bcc> {
240 let bcc = self
241 .with_effective_artifacts(input_values, |artifacts| {
242 let (_, _, bcc) = artifacts.into_tuple();
243 Ok(bcc)
244 })
245 .context("In ResidentHal::get_attestation_chain: Failed to get effective_artifacts.")?;
246
247 Ok(Bcc { data: bcc })
248 }
249
derive(&self, input_values: &[BinderInputValues]) -> Result<BccHandover>250 fn derive(&self, input_values: &[BinderInputValues]) -> Result<BccHandover> {
251 let (cdi_attest, cdi_seal, bcc): (Vec<u8>, Vec<u8>, Vec<u8>) = self
252 .with_effective_artifacts(input_values, |artifacts| {
253 let (cdi_attest, cdi_seal, bcc) = artifacts.into_tuple();
254 Ok((cdi_attest[..].to_vec(), cdi_seal[..].to_vec(), bcc))
255 })?;
256
257 utils::make_bcc_handover(
258 &cdi_attest
259 .as_slice()
260 .try_into()
261 .context("In ResidentHal::derive: Trying to convert cdi_attest to sized array.")?,
262 &cdi_seal
263 .as_slice()
264 .try_into()
265 .context("In ResidentHal::derive: Trying to convert cdi_seal to sized array.")?,
266 &bcc,
267 )
268 .context("In ResidentHal::derive: Trying to construct BccHandover.")
269 }
270
demote(&self, input_values: &[BinderInputValues]) -> Result<()>271 fn demote(&self, input_values: &[BinderInputValues]) -> Result<()> {
272 let mut artifacts = self.artifacts.write().unwrap();
273
274 let artifacts_clone = (*artifacts).clone();
275
276 // Safety: run_forked may not be called from a multi threaded process.
277 // This requirement is propagated to the public interface of this module through
278 // `ResidentHal::new`
279 *artifacts = run_forked(|| {
280 let new_artifacts =
281 artifacts_clone.with_artifacts(|a| ResidentArtifacts::new_from(a))?;
282 let input_values: Vec<utils::InputValues> =
283 input_values.iter().map(|v| v.into()).collect();
284
285 let new_artifacts = new_artifacts
286 .execute_steps(input_values.iter().map(|v| v as &dyn dice::InputValues))
287 .context("In ResidentHal::get_effective_artifacts:")?;
288 artifacts_clone.update(&new_artifacts)
289 })?;
290
291 Ok(())
292 }
293 }
294
295 /// Implements android.hardware.security.dice.IDiceDevice. Forwards public API calls
296 /// to the given DiceHalImpl backend.
297 pub struct DiceDevice {
298 hal_impl: Arc<dyn DiceHalImpl + Sync + Send>,
299 }
300
301 impl DiceDevice {
302 /// Constructs an instance of DiceDevice, wraps it with a BnDiceDevice object and
303 /// returns a strong pointer to the binder. The result can be used to register
304 /// the service with service manager.
new_as_binder( hal_impl: Arc<dyn DiceHalImpl + Sync + Send>, ) -> Result<Strong<dyn IDiceDevice>>305 pub fn new_as_binder(
306 hal_impl: Arc<dyn DiceHalImpl + Sync + Send>,
307 ) -> Result<Strong<dyn IDiceDevice>> {
308 let result = BnDiceDevice::new_binder(DiceDevice { hal_impl }, BinderFeatures::default());
309 Ok(result)
310 }
311 }
312
313 impl binder::Interface for DiceDevice {}
314
315 impl IDiceDevice for DiceDevice {
sign(&self, input_values: &[BinderInputValues], message: &[u8]) -> BinderResult<Signature>316 fn sign(&self, input_values: &[BinderInputValues], message: &[u8]) -> BinderResult<Signature> {
317 map_or_log_err(self.hal_impl.sign(input_values, message), Ok)
318 }
getAttestationChain(&self, input_values: &[BinderInputValues]) -> BinderResult<Bcc>319 fn getAttestationChain(&self, input_values: &[BinderInputValues]) -> BinderResult<Bcc> {
320 map_or_log_err(self.hal_impl.get_attestation_chain(input_values), Ok)
321 }
derive(&self, input_values: &[BinderInputValues]) -> BinderResult<BccHandover>322 fn derive(&self, input_values: &[BinderInputValues]) -> BinderResult<BccHandover> {
323 map_or_log_err(self.hal_impl.derive(input_values), Ok)
324 }
demote(&self, input_values: &[BinderInputValues]) -> BinderResult<()>325 fn demote(&self, input_values: &[BinderInputValues]) -> BinderResult<()> {
326 map_or_log_err(self.hal_impl.demote(input_values), Ok)
327 }
328 }
329
330 #[cfg(test)]
331 mod test {
332 use super::*;
333 use android_hardware_security_dice::aidl::android::hardware::security::dice::{
334 BccHandover::BccHandover, Config::Config as BinderConfig,
335 InputValues::InputValues as BinderInputValues, Mode::Mode as BinderMode,
336 };
337 use anyhow::{Context, Result};
338 use diced_open_dice_cbor as dice;
339 use diced_sample_inputs;
340 use diced_utils as utils;
341
342 #[derive(Debug, Serialize, Deserialize, Clone)]
343 struct InsecureSerializableArtifacts {
344 cdi_attest: [u8; dice::CDI_SIZE],
345 cdi_seal: [u8; dice::CDI_SIZE],
346 bcc: Vec<u8>,
347 }
348
349 impl DiceArtifacts for InsecureSerializableArtifacts {
cdi_attest(&self) -> &[u8; dice::CDI_SIZE]350 fn cdi_attest(&self) -> &[u8; dice::CDI_SIZE] {
351 &self.cdi_attest
352 }
cdi_seal(&self) -> &[u8; dice::CDI_SIZE]353 fn cdi_seal(&self) -> &[u8; dice::CDI_SIZE] {
354 &self.cdi_seal
355 }
bcc(&self) -> Vec<u8>356 fn bcc(&self) -> Vec<u8> {
357 self.bcc.clone()
358 }
359 }
360
361 impl UpdatableDiceArtifacts for InsecureSerializableArtifacts {
with_artifacts<F, T>(&self, f: F) -> Result<T> where F: FnOnce(&dyn DiceArtifacts) -> Result<T>,362 fn with_artifacts<F, T>(&self, f: F) -> Result<T>
363 where
364 F: FnOnce(&dyn DiceArtifacts) -> Result<T>,
365 {
366 f(self)
367 }
update(self, new_artifacts: &impl DiceArtifacts) -> Result<Self>368 fn update(self, new_artifacts: &impl DiceArtifacts) -> Result<Self> {
369 Ok(Self {
370 cdi_attest: *new_artifacts.cdi_attest(),
371 cdi_seal: *new_artifacts.cdi_seal(),
372 bcc: new_artifacts.bcc(),
373 })
374 }
375 }
376
make_input_values( code: &str, config_name: &str, authority: &str, ) -> Result<BinderInputValues>377 fn make_input_values(
378 code: &str,
379 config_name: &str,
380 authority: &str,
381 ) -> Result<BinderInputValues> {
382 let mut dice_ctx = dice::OpenDiceCborContext::new();
383 Ok(BinderInputValues {
384 codeHash: dice_ctx
385 .hash(code.as_bytes())
386 .context("In make_input_values: code hash failed.")?
387 .as_slice()
388 .try_into()?,
389 config: BinderConfig {
390 desc: dice::bcc::format_config_descriptor(Some(config_name), None, true)
391 .context("In make_input_values: Failed to format config descriptor.")?,
392 },
393 authorityHash: dice_ctx
394 .hash(authority.as_bytes())
395 .context("In make_input_values: authority hash failed.")?
396 .as_slice()
397 .try_into()?,
398 authorityDescriptor: None,
399 mode: BinderMode::NORMAL,
400 hidden: [0; dice::HIDDEN_SIZE],
401 })
402 }
403
404 /// Test the resident artifact batched derivation in process.
405 #[test]
derive_with_resident_artifacts() -> Result<()>406 fn derive_with_resident_artifacts() -> Result<()> {
407 let (cdi_attest, cdi_seal, bcc) = diced_sample_inputs::make_sample_bcc_and_cdis()?;
408
409 let artifacts =
410 ResidentArtifacts::new(cdi_attest[..].try_into()?, cdi_seal[..].try_into()?, &bcc)?;
411
412 let input_values = &[
413 make_input_values("component 1 code", "component 1", "component 1 authority")?,
414 make_input_values("component 2 code", "component 2", "component 2 authority")?,
415 make_input_values("component 3 code", "component 3", "component 3 authority")?,
416 ];
417
418 let input_values: Vec<utils::InputValues> = input_values.iter().map(|v| v.into()).collect();
419
420 let new_artifacts =
421 artifacts.execute_steps(input_values.iter().map(|v| v as &dyn dice::InputValues))?;
422
423 let result = utils::make_bcc_handover(
424 new_artifacts.cdi_attest(),
425 new_artifacts.cdi_seal(),
426 &new_artifacts.bcc(),
427 )?;
428
429 assert_eq!(result, make_derive_test_vector());
430 Ok(())
431 }
432
433 /// Test the ResidentHal hal implementation which performs the derivation in a separate
434 /// process and returns the result through a pipe. This test compares the result against
435 /// the same test vector as the in process test above.
436 #[test]
derive_with_insecure_artifacts() -> Result<()>437 fn derive_with_insecure_artifacts() -> Result<()> {
438 let (cdi_attest, cdi_seal, bcc) = diced_sample_inputs::make_sample_bcc_and_cdis()?;
439
440 // Safety: ResidentHal can only be used in single threaded environments.
441 // On-device Rust tests run each test in a separate process.
442 let hal_impl = unsafe {
443 ResidentHal::new(InsecureSerializableArtifacts {
444 cdi_attest: cdi_attest[..].try_into()?,
445 cdi_seal: cdi_seal[..].try_into()?,
446 bcc,
447 })
448 }
449 .expect("Failed to create ResidentHal.");
450
451 let bcc_handover = hal_impl
452 .derive(&[
453 make_input_values("component 1 code", "component 1", "component 1 authority")?,
454 make_input_values("component 2 code", "component 2", "component 2 authority")?,
455 make_input_values("component 3 code", "component 3", "component 3 authority")?,
456 ])
457 .expect("Failed to derive artifacts.");
458
459 assert_eq!(bcc_handover, make_derive_test_vector());
460 Ok(())
461 }
462
463 /// Demoting the implementation two steps and then performing one step of child derivation
464 /// must yield the same outcome as three derivations with the same input values.
465 #[test]
demote() -> Result<()>466 fn demote() -> Result<()> {
467 let (cdi_attest, cdi_seal, bcc) = diced_sample_inputs::make_sample_bcc_and_cdis()?;
468
469 // Safety: ResidentHal can only be used in single threaded environments.
470 // On-device Rust tests run each test in a separate process.
471 let hal_impl = unsafe {
472 ResidentHal::new(InsecureSerializableArtifacts {
473 cdi_attest: cdi_attest[..].try_into()?,
474 cdi_seal: cdi_seal[..].try_into()?,
475 bcc,
476 })
477 }
478 .expect("Failed to create ResidentHal.");
479
480 hal_impl
481 .demote(&[
482 make_input_values("component 1 code", "component 1", "component 1 authority")?,
483 make_input_values("component 2 code", "component 2", "component 2 authority")?,
484 ])
485 .expect("Failed to demote implementation.");
486
487 let bcc_handover = hal_impl
488 .derive(&[make_input_values(
489 "component 3 code",
490 "component 3",
491 "component 3 authority",
492 )?])
493 .expect("Failed to derive artifacts.");
494
495 assert_eq!(bcc_handover, make_derive_test_vector());
496 Ok(())
497 }
498
make_derive_test_vector() -> BccHandover499 fn make_derive_test_vector() -> BccHandover {
500 utils::make_bcc_handover(
501 &[
502 // cdi_attest
503 0x8f, 0xdf, 0x93, 0x67, 0xd7, 0x0e, 0xf8, 0xb8, 0xd2, 0x9c, 0x30, 0xeb, 0x4e, 0x9b,
504 0x71, 0x5f, 0x9a, 0x5b, 0x67, 0xa6, 0x29, 0xe0, 0x00, 0x9b, 0x4d, 0xe6, 0x95, 0xcf,
505 0xf9, 0xed, 0x5e, 0x9b,
506 ],
507 &[
508 // cdi_seal
509 0x15, 0x3e, 0xd6, 0x30, 0x5a, 0x8d, 0x4b, 0x6f, 0x07, 0x3f, 0x5d, 0x89, 0xc5, 0x6e,
510 0x30, 0xba, 0x05, 0x56, 0xfc, 0x66, 0xf4, 0xae, 0xce, 0x7f, 0x81, 0xb9, 0xc5, 0x21,
511 0x9b, 0x49, 0x3d, 0xe1,
512 ],
513 &[
514 // bcc
515 0x87, 0xa5, 0x01, 0x01, 0x03, 0x27, 0x04, 0x02, 0x20, 0x06, 0x21, 0x58, 0x20, 0x3e,
516 0x85, 0xe5, 0x72, 0x75, 0x55, 0xe5, 0x1e, 0xe7, 0xf3, 0x35, 0x94, 0x8e, 0xbb, 0xbd,
517 0x74, 0x1e, 0x1d, 0xca, 0x49, 0x9c, 0x97, 0x39, 0x77, 0x06, 0xd3, 0xc8, 0x6e, 0x8b,
518 0xd7, 0x33, 0xf9, 0x84, 0x43, 0xa1, 0x01, 0x27, 0xa0, 0x59, 0x01, 0x8a, 0xa9, 0x01,
519 0x78, 0x28, 0x34, 0x32, 0x64, 0x38, 0x38, 0x36, 0x34, 0x66, 0x39, 0x37, 0x62, 0x36,
520 0x35, 0x34, 0x37, 0x61, 0x35, 0x30, 0x63, 0x31, 0x65, 0x30, 0x61, 0x37, 0x34, 0x39,
521 0x66, 0x38, 0x65, 0x66, 0x38, 0x62, 0x38, 0x31, 0x65, 0x63, 0x36, 0x32, 0x61, 0x66,
522 0x02, 0x78, 0x28, 0x31, 0x66, 0x36, 0x39, 0x36, 0x66, 0x30, 0x37, 0x32, 0x35, 0x32,
523 0x66, 0x32, 0x39, 0x65, 0x39, 0x33, 0x66, 0x65, 0x34, 0x64, 0x65, 0x31, 0x39, 0x65,
524 0x65, 0x33, 0x32, 0x63, 0x64, 0x38, 0x31, 0x64, 0x63, 0x34, 0x30, 0x34, 0x65, 0x37,
525 0x36, 0x3a, 0x00, 0x47, 0x44, 0x50, 0x58, 0x40, 0x16, 0x48, 0xf2, 0x55, 0x53, 0x23,
526 0xdd, 0x15, 0x2e, 0x83, 0x38, 0xc3, 0x64, 0x38, 0x63, 0x26, 0x0f, 0xcf, 0x5b, 0xd1,
527 0x3a, 0xd3, 0x40, 0x3e, 0x23, 0xf8, 0x34, 0x4c, 0x6d, 0xa2, 0xbe, 0x25, 0x1c, 0xb0,
528 0x29, 0xe8, 0xc3, 0xfb, 0xb8, 0x80, 0xdc, 0xb1, 0xd2, 0xb3, 0x91, 0x4d, 0xd3, 0xfb,
529 0x01, 0x0f, 0xe4, 0xe9, 0x46, 0xa2, 0xc0, 0x26, 0x57, 0x5a, 0xba, 0x30, 0xf7, 0x15,
530 0x98, 0x14, 0x3a, 0x00, 0x47, 0x44, 0x53, 0x56, 0xa3, 0x3a, 0x00, 0x01, 0x11, 0x71,
531 0x63, 0x41, 0x42, 0x4c, 0x3a, 0x00, 0x01, 0x11, 0x72, 0x01, 0x3a, 0x00, 0x01, 0x11,
532 0x73, 0xf6, 0x3a, 0x00, 0x47, 0x44, 0x52, 0x58, 0x40, 0x47, 0xae, 0x42, 0x27, 0x4c,
533 0xcb, 0x65, 0x4d, 0xee, 0x74, 0x2d, 0x05, 0x78, 0x2a, 0x08, 0x2a, 0xa5, 0xf0, 0xcf,
534 0xea, 0x3e, 0x60, 0xee, 0x97, 0x11, 0x4b, 0x5b, 0xe6, 0x05, 0x0c, 0xe8, 0x90, 0xf5,
535 0x22, 0xc4, 0xc6, 0x67, 0x7a, 0x22, 0x27, 0x17, 0xb3, 0x79, 0xcc, 0x37, 0x64, 0x5e,
536 0x19, 0x4f, 0x96, 0x37, 0x67, 0x3c, 0xd0, 0xc5, 0xed, 0x0f, 0xdd, 0xe7, 0x2e, 0x4f,
537 0x70, 0x97, 0x30, 0x3a, 0x00, 0x47, 0x44, 0x54, 0x58, 0x40, 0xf9, 0x00, 0x9d, 0xc2,
538 0x59, 0x09, 0xe0, 0xb6, 0x98, 0xbd, 0xe3, 0x97, 0x4a, 0xcb, 0x3c, 0xe7, 0x6b, 0x24,
539 0xc3, 0xe4, 0x98, 0xdd, 0xa9, 0x6a, 0x41, 0x59, 0x15, 0xb1, 0x23, 0xe6, 0xc8, 0xdf,
540 0xfb, 0x52, 0xb4, 0x52, 0xc1, 0xb9, 0x61, 0xdd, 0xbc, 0x5b, 0x37, 0x0e, 0x12, 0x12,
541 0xb2, 0xfd, 0xc1, 0x09, 0xb0, 0xcf, 0x33, 0x81, 0x4c, 0xc6, 0x29, 0x1b, 0x99, 0xea,
542 0xae, 0xfd, 0xaa, 0x0d, 0x3a, 0x00, 0x47, 0x44, 0x56, 0x41, 0x01, 0x3a, 0x00, 0x47,
543 0x44, 0x57, 0x58, 0x2d, 0xa5, 0x01, 0x01, 0x03, 0x27, 0x04, 0x81, 0x02, 0x20, 0x06,
544 0x21, 0x58, 0x20, 0xb1, 0x02, 0xcc, 0x2c, 0xb2, 0x6a, 0x3b, 0xe9, 0xc1, 0xd3, 0x95,
545 0x10, 0xa0, 0xe1, 0xff, 0x51, 0xde, 0x57, 0xd5, 0x65, 0x28, 0xfd, 0x7f, 0xeb, 0xd4,
546 0xca, 0x15, 0xf3, 0xca, 0xdf, 0x37, 0x88, 0x3a, 0x00, 0x47, 0x44, 0x58, 0x41, 0x20,
547 0x58, 0x40, 0x58, 0xd8, 0x03, 0x24, 0x53, 0x60, 0x57, 0xa9, 0x09, 0xfa, 0xab, 0xdc,
548 0x57, 0x1e, 0xf0, 0xe5, 0x1e, 0x51, 0x6f, 0x9e, 0xa3, 0x42, 0xe6, 0x6a, 0x8c, 0xaa,
549 0xad, 0x08, 0x48, 0xde, 0x7f, 0x4f, 0x6e, 0x2f, 0x7f, 0x39, 0x6c, 0xa1, 0xf8, 0x42,
550 0x71, 0xfe, 0x17, 0x3d, 0xca, 0x31, 0x83, 0x92, 0xed, 0xbb, 0x40, 0xb8, 0x10, 0xe0,
551 0xf2, 0x5a, 0x99, 0x53, 0x38, 0x46, 0x33, 0x97, 0x78, 0x05, 0x84, 0x43, 0xa1, 0x01,
552 0x27, 0xa0, 0x59, 0x01, 0x8a, 0xa9, 0x01, 0x78, 0x28, 0x31, 0x66, 0x36, 0x39, 0x36,
553 0x66, 0x30, 0x37, 0x32, 0x35, 0x32, 0x66, 0x32, 0x39, 0x65, 0x39, 0x33, 0x66, 0x65,
554 0x34, 0x64, 0x65, 0x31, 0x39, 0x65, 0x65, 0x33, 0x32, 0x63, 0x64, 0x38, 0x31, 0x64,
555 0x63, 0x34, 0x30, 0x34, 0x65, 0x37, 0x36, 0x02, 0x78, 0x28, 0x32, 0x35, 0x39, 0x34,
556 0x38, 0x39, 0x65, 0x36, 0x39, 0x37, 0x34, 0x38, 0x37, 0x30, 0x35, 0x64, 0x65, 0x33,
557 0x65, 0x32, 0x66, 0x34, 0x34, 0x32, 0x36, 0x37, 0x65, 0x61, 0x34, 0x39, 0x33, 0x38,
558 0x66, 0x66, 0x36, 0x61, 0x35, 0x37, 0x32, 0x35, 0x3a, 0x00, 0x47, 0x44, 0x50, 0x58,
559 0x40, 0xa4, 0x0c, 0xcb, 0xc1, 0xbf, 0xfa, 0xcc, 0xfd, 0xeb, 0xf4, 0xfc, 0x43, 0x83,
560 0x7f, 0x46, 0x8d, 0xd8, 0xd8, 0x14, 0xc1, 0x96, 0x14, 0x1f, 0x6e, 0xb3, 0xa0, 0xd9,
561 0x56, 0xb3, 0xbf, 0x2f, 0xfa, 0x88, 0x70, 0x11, 0x07, 0x39, 0xa4, 0xd2, 0xa9, 0x6b,
562 0x18, 0x28, 0xe8, 0x29, 0x20, 0x49, 0x0f, 0xbb, 0x8d, 0x08, 0x8c, 0xc6, 0x54, 0xe9,
563 0x71, 0xd2, 0x7e, 0xa4, 0xfe, 0x58, 0x7f, 0xd3, 0xc7, 0x3a, 0x00, 0x47, 0x44, 0x53,
564 0x56, 0xa3, 0x3a, 0x00, 0x01, 0x11, 0x71, 0x63, 0x41, 0x56, 0x42, 0x3a, 0x00, 0x01,
565 0x11, 0x72, 0x01, 0x3a, 0x00, 0x01, 0x11, 0x73, 0xf6, 0x3a, 0x00, 0x47, 0x44, 0x52,
566 0x58, 0x40, 0x93, 0x17, 0xe1, 0x11, 0x27, 0x59, 0xd0, 0xef, 0x75, 0x0b, 0x2b, 0x1c,
567 0x0f, 0x5f, 0x52, 0xc3, 0x29, 0x23, 0xb5, 0x2a, 0xe6, 0x12, 0x72, 0x6f, 0x39, 0x86,
568 0x65, 0x2d, 0xf2, 0xe4, 0xe7, 0xd0, 0xaf, 0x0e, 0xa7, 0x99, 0x16, 0x89, 0x97, 0x21,
569 0xf7, 0xdc, 0x89, 0xdc, 0xde, 0xbb, 0x94, 0x88, 0x1f, 0xda, 0xe2, 0xf3, 0xe0, 0x54,
570 0xf9, 0x0e, 0x29, 0xb1, 0xbd, 0xe1, 0x0c, 0x0b, 0xd7, 0xf6, 0x3a, 0x00, 0x47, 0x44,
571 0x54, 0x58, 0x40, 0xb2, 0x69, 0x05, 0x48, 0x56, 0xb5, 0xfa, 0x55, 0x6f, 0xac, 0x56,
572 0xd9, 0x02, 0x35, 0x2b, 0xaa, 0x4c, 0xba, 0x28, 0xdd, 0x82, 0x3a, 0x86, 0xf5, 0xd4,
573 0xc2, 0xf1, 0xf9, 0x35, 0x7d, 0xe4, 0x43, 0x13, 0xbf, 0xfe, 0xd3, 0x36, 0xd8, 0x1c,
574 0x12, 0x78, 0x5c, 0x9c, 0x3e, 0xf6, 0x66, 0xef, 0xab, 0x3d, 0x0f, 0x89, 0xa4, 0x6f,
575 0xc9, 0x72, 0xee, 0x73, 0x43, 0x02, 0x8a, 0xef, 0xbc, 0x05, 0x98, 0x3a, 0x00, 0x47,
576 0x44, 0x56, 0x41, 0x01, 0x3a, 0x00, 0x47, 0x44, 0x57, 0x58, 0x2d, 0xa5, 0x01, 0x01,
577 0x03, 0x27, 0x04, 0x81, 0x02, 0x20, 0x06, 0x21, 0x58, 0x20, 0x96, 0x6d, 0x96, 0x42,
578 0xda, 0x64, 0x51, 0xad, 0xfa, 0x00, 0xbc, 0xbc, 0x95, 0x8a, 0xb0, 0xb9, 0x76, 0x01,
579 0xe6, 0xbd, 0xc0, 0x26, 0x79, 0x26, 0xfc, 0x0f, 0x1d, 0x87, 0x65, 0xf1, 0xf3, 0x99,
580 0x3a, 0x00, 0x47, 0x44, 0x58, 0x41, 0x20, 0x58, 0x40, 0x10, 0x7f, 0x77, 0xad, 0x70,
581 0xbd, 0x52, 0x81, 0x28, 0x8d, 0x24, 0x81, 0xb4, 0x3f, 0x21, 0x68, 0x9f, 0xc3, 0x80,
582 0x68, 0x86, 0x55, 0xfb, 0x2e, 0x6d, 0x96, 0xe1, 0xe1, 0xb7, 0x28, 0x8d, 0x63, 0x85,
583 0xba, 0x2a, 0x01, 0x33, 0x87, 0x60, 0x63, 0xbb, 0x16, 0x3f, 0x2f, 0x3d, 0xf4, 0x2d,
584 0x48, 0x5b, 0x87, 0xed, 0xda, 0x34, 0xeb, 0x9c, 0x4d, 0x14, 0xac, 0x65, 0xf4, 0xfa,
585 0xef, 0x45, 0x0b, 0x84, 0x43, 0xa1, 0x01, 0x27, 0xa0, 0x59, 0x01, 0x8f, 0xa9, 0x01,
586 0x78, 0x28, 0x32, 0x35, 0x39, 0x34, 0x38, 0x39, 0x65, 0x36, 0x39, 0x37, 0x34, 0x38,
587 0x37, 0x30, 0x35, 0x64, 0x65, 0x33, 0x65, 0x32, 0x66, 0x34, 0x34, 0x32, 0x36, 0x37,
588 0x65, 0x61, 0x34, 0x39, 0x33, 0x38, 0x66, 0x66, 0x36, 0x61, 0x35, 0x37, 0x32, 0x35,
589 0x02, 0x78, 0x28, 0x35, 0x64, 0x34, 0x65, 0x64, 0x37, 0x66, 0x34, 0x31, 0x37, 0x61,
590 0x39, 0x35, 0x34, 0x61, 0x31, 0x38, 0x31, 0x34, 0x30, 0x37, 0x62, 0x35, 0x38, 0x38,
591 0x35, 0x61, 0x66, 0x64, 0x37, 0x32, 0x61, 0x35, 0x62, 0x66, 0x34, 0x30, 0x64, 0x61,
592 0x36, 0x3a, 0x00, 0x47, 0x44, 0x50, 0x58, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
593 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
594 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
595 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
596 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
597 0x00, 0x00, 0x3a, 0x00, 0x47, 0x44, 0x53, 0x58, 0x1a, 0xa3, 0x3a, 0x00, 0x01, 0x11,
598 0x71, 0x67, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x3a, 0x00, 0x01, 0x11, 0x72,
599 0x0c, 0x3a, 0x00, 0x01, 0x11, 0x73, 0xf6, 0x3a, 0x00, 0x47, 0x44, 0x52, 0x58, 0x40,
600 0x26, 0x1a, 0xbd, 0x26, 0xd8, 0x37, 0x8f, 0x4a, 0xf2, 0x9e, 0x49, 0x4d, 0x93, 0x23,
601 0xc4, 0x6e, 0x02, 0xda, 0xe0, 0x00, 0x02, 0xe7, 0xed, 0x29, 0xdf, 0x2b, 0xb3, 0x69,
602 0xf3, 0x55, 0x0e, 0x4c, 0x22, 0xdc, 0xcf, 0xf5, 0x92, 0xc9, 0xfa, 0x78, 0x98, 0xf1,
603 0x0e, 0x55, 0x5f, 0xf4, 0x45, 0xed, 0xc0, 0x0a, 0x72, 0x2a, 0x7a, 0x3a, 0xd2, 0xb1,
604 0xf7, 0x76, 0xfe, 0x2a, 0x6b, 0x7b, 0x2a, 0x53, 0x3a, 0x00, 0x47, 0x44, 0x54, 0x58,
605 0x40, 0x04, 0x25, 0x5d, 0x60, 0x5f, 0x5c, 0x45, 0x0d, 0xf2, 0x9a, 0x6e, 0x99, 0x30,
606 0x03, 0xb8, 0xd6, 0xe1, 0x99, 0x71, 0x1b, 0xf8, 0x44, 0xfa, 0xb5, 0x31, 0x79, 0x1c,
607 0x37, 0x68, 0x4e, 0x1d, 0xc0, 0x24, 0x74, 0x68, 0xf8, 0x80, 0x20, 0x3e, 0x44, 0xb1,
608 0x43, 0xd2, 0x9c, 0xfc, 0x12, 0x9e, 0x77, 0x0a, 0xde, 0x29, 0x24, 0xff, 0x2e, 0xfa,
609 0xc7, 0x10, 0xd5, 0x73, 0xd4, 0xc6, 0xdf, 0x62, 0x9f, 0x3a, 0x00, 0x47, 0x44, 0x56,
610 0x41, 0x01, 0x3a, 0x00, 0x47, 0x44, 0x57, 0x58, 0x2d, 0xa5, 0x01, 0x01, 0x03, 0x27,
611 0x04, 0x81, 0x02, 0x20, 0x06, 0x21, 0x58, 0x20, 0xdb, 0xe7, 0x5b, 0x3f, 0xa3, 0x42,
612 0xb0, 0x9c, 0xf8, 0x40, 0x8c, 0xb0, 0x9c, 0xf0, 0x0a, 0xaf, 0xdf, 0x6f, 0xe5, 0x09,
613 0x21, 0x11, 0x92, 0xe1, 0xf8, 0xc5, 0x09, 0x02, 0x3d, 0x1f, 0xb7, 0xc5, 0x3a, 0x00,
614 0x47, 0x44, 0x58, 0x41, 0x20, 0x58, 0x40, 0xc4, 0xc1, 0xd7, 0x1c, 0x2d, 0x26, 0x89,
615 0x22, 0xcf, 0xa6, 0x99, 0x77, 0x30, 0x84, 0x86, 0x27, 0x59, 0x8f, 0xd8, 0x08, 0x75,
616 0xe0, 0xb2, 0xef, 0xf9, 0xfa, 0xa5, 0x40, 0x8c, 0xd3, 0xeb, 0xbb, 0xda, 0xf2, 0xc8,
617 0xae, 0x41, 0x22, 0x50, 0x9c, 0xe8, 0xb2, 0x9c, 0x9b, 0x3f, 0x8a, 0x78, 0x76, 0xab,
618 0xd0, 0xbe, 0xfc, 0xe4, 0x79, 0xcb, 0x1b, 0x2b, 0xaa, 0x4d, 0xdd, 0x15, 0x61, 0x42,
619 0x06, 0x84, 0x43, 0xa1, 0x01, 0x27, 0xa0, 0x59, 0x01, 0x8d, 0xa9, 0x01, 0x78, 0x28,
620 0x35, 0x64, 0x34, 0x65, 0x64, 0x37, 0x66, 0x34, 0x31, 0x37, 0x61, 0x39, 0x35, 0x34,
621 0x61, 0x31, 0x38, 0x31, 0x34, 0x30, 0x37, 0x62, 0x35, 0x38, 0x38, 0x35, 0x61, 0x66,
622 0x64, 0x37, 0x32, 0x61, 0x35, 0x62, 0x66, 0x34, 0x30, 0x64, 0x61, 0x36, 0x02, 0x78,
623 0x28, 0x36, 0x39, 0x62, 0x31, 0x37, 0x36, 0x37, 0x35, 0x38, 0x61, 0x36, 0x66, 0x34,
624 0x34, 0x62, 0x35, 0x65, 0x38, 0x39, 0x39, 0x63, 0x64, 0x65, 0x33, 0x63, 0x66, 0x34,
625 0x35, 0x31, 0x39, 0x61, 0x39, 0x33, 0x35, 0x62, 0x63, 0x39, 0x66, 0x65, 0x34, 0x3a,
626 0x00, 0x47, 0x44, 0x50, 0x58, 0x40, 0x31, 0x0d, 0x31, 0xfa, 0x78, 0x58, 0x33, 0xf2,
627 0xf8, 0x58, 0x6b, 0xe9, 0x68, 0x32, 0x44, 0xd0, 0xfc, 0x2d, 0xe1, 0xfc, 0xe1, 0xc2,
628 0x4e, 0x2b, 0xa8, 0x2c, 0xa1, 0xc1, 0x48, 0xc6, 0xaa, 0x91, 0x89, 0x4f, 0xb7, 0x9c,
629 0x40, 0x74, 0x21, 0x36, 0x31, 0x45, 0x09, 0xdf, 0x0c, 0xb4, 0xf9, 0x9a, 0x59, 0xae,
630 0x4f, 0x21, 0x10, 0xc1, 0x38, 0xa8, 0xa2, 0xbe, 0xc6, 0x36, 0xf0, 0x56, 0x58, 0xdb,
631 0x3a, 0x00, 0x47, 0x44, 0x53, 0x58, 0x18, 0xa2, 0x3a, 0x00, 0x01, 0x11, 0x71, 0x6b,
632 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x20, 0x31, 0x3a, 0x00, 0x01,
633 0x11, 0x73, 0xf6, 0x3a, 0x00, 0x47, 0x44, 0x52, 0x58, 0x40, 0xce, 0x8a, 0x30, 0x4e,
634 0x31, 0x53, 0xea, 0xdd, 0x2f, 0xbd, 0x15, 0xbc, 0x6b, 0x0f, 0xe7, 0x43, 0x50, 0xef,
635 0x65, 0xec, 0x4e, 0x21, 0x64, 0x6e, 0x41, 0x22, 0xac, 0x87, 0xda, 0xf1, 0xf2, 0x80,
636 0xc6, 0x8a, 0xd8, 0x7b, 0xe8, 0xe2, 0x9b, 0x87, 0x21, 0x5e, 0x26, 0x23, 0x11, 0x89,
637 0x86, 0x57, 0x2d, 0x47, 0x73, 0x3f, 0x47, 0x87, 0xfa, 0x58, 0x5c, 0x78, 0x7b, 0xa3,
638 0xfc, 0x2b, 0x6c, 0xed, 0x3a, 0x00, 0x47, 0x44, 0x54, 0x58, 0x40, 0xd8, 0x40, 0xa0,
639 0x60, 0x45, 0x28, 0x5d, 0xd4, 0xc1, 0x08, 0x3c, 0xbc, 0x91, 0xf4, 0xa6, 0xa4, 0xde,
640 0xd3, 0x3d, 0xbb, 0x24, 0x46, 0xa3, 0x58, 0x49, 0x57, 0x4d, 0x2e, 0x6d, 0x7a, 0x78,
641 0x4b, 0x9d, 0x28, 0x9a, 0x4e, 0xf1, 0x23, 0x06, 0x35, 0xff, 0x8e, 0x1e, 0xb3, 0x02,
642 0x63, 0x62, 0x9a, 0x50, 0x6d, 0x18, 0x70, 0x8e, 0xe3, 0x2e, 0x29, 0xb4, 0x22, 0x71,
643 0x31, 0x39, 0x65, 0xd5, 0xb5, 0x3a, 0x00, 0x47, 0x44, 0x56, 0x41, 0x01, 0x3a, 0x00,
644 0x47, 0x44, 0x57, 0x58, 0x2d, 0xa5, 0x01, 0x01, 0x03, 0x27, 0x04, 0x81, 0x02, 0x20,
645 0x06, 0x21, 0x58, 0x20, 0x51, 0x3c, 0x4b, 0x56, 0x0b, 0x49, 0x0b, 0xee, 0xc5, 0x71,
646 0xd4, 0xe7, 0xbc, 0x44, 0x27, 0x4f, 0x4e, 0x67, 0xfc, 0x3a, 0xb9, 0x47, 0x8c, 0x6f,
647 0x24, 0x29, 0xf8, 0xb8, 0x2f, 0xa7, 0xb3, 0x4d, 0x3a, 0x00, 0x47, 0x44, 0x58, 0x41,
648 0x20, 0x58, 0x40, 0x4e, 0x6d, 0x0e, 0x2b, 0x1d, 0x44, 0x99, 0xb6, 0x63, 0x07, 0x86,
649 0x1a, 0xce, 0x4b, 0xdc, 0xd1, 0x3a, 0xdc, 0xbf, 0xaa, 0xb3, 0x06, 0xd9, 0xb5, 0x5c,
650 0x75, 0xf0, 0x14, 0x63, 0xa9, 0x1e, 0x7c, 0x56, 0x62, 0x2c, 0xa5, 0xda, 0xc9, 0x81,
651 0xcb, 0x3d, 0x63, 0x32, 0x6b, 0x76, 0x81, 0xd2, 0x93, 0xeb, 0xac, 0xfe, 0x0c, 0x87,
652 0x66, 0x9e, 0x87, 0x82, 0xb4, 0x81, 0x6e, 0x33, 0xf1, 0x08, 0x01, 0x84, 0x43, 0xa1,
653 0x01, 0x27, 0xa0, 0x59, 0x01, 0x8d, 0xa9, 0x01, 0x78, 0x28, 0x36, 0x39, 0x62, 0x31,
654 0x37, 0x36, 0x37, 0x35, 0x38, 0x61, 0x36, 0x66, 0x34, 0x34, 0x62, 0x35, 0x65, 0x38,
655 0x39, 0x39, 0x63, 0x64, 0x65, 0x33, 0x63, 0x66, 0x34, 0x35, 0x31, 0x39, 0x61, 0x39,
656 0x33, 0x35, 0x62, 0x63, 0x39, 0x66, 0x65, 0x34, 0x02, 0x78, 0x28, 0x32, 0x39, 0x65,
657 0x34, 0x62, 0x61, 0x63, 0x33, 0x30, 0x31, 0x65, 0x66, 0x36, 0x35, 0x61, 0x38, 0x31,
658 0x31, 0x62, 0x39, 0x39, 0x62, 0x30, 0x33, 0x64, 0x65, 0x39, 0x35, 0x34, 0x65, 0x61,
659 0x37, 0x36, 0x61, 0x38, 0x39, 0x31, 0x37, 0x38, 0x35, 0x3a, 0x00, 0x47, 0x44, 0x50,
660 0x58, 0x40, 0xa4, 0x03, 0xe3, 0xde, 0x44, 0x96, 0xed, 0x31, 0x41, 0xa0, 0xba, 0x59,
661 0xee, 0x2b, 0x03, 0x65, 0xcb, 0x63, 0x14, 0x78, 0xbe, 0xad, 0x24, 0x33, 0xb8, 0x6b,
662 0x52, 0xd8, 0xab, 0xd5, 0x79, 0x84, 0x98, 0x6c, 0xc2, 0x66, 0xeb, 0x6c, 0x24, 0xa6,
663 0xfa, 0x32, 0xa8, 0x16, 0xb8, 0x64, 0x37, 0x2b, 0xd4, 0xc0, 0xc4, 0xc2, 0x63, 0x25,
664 0x10, 0xce, 0x47, 0xe3, 0x49, 0xad, 0x41, 0xf5, 0xc8, 0xf6, 0x3a, 0x00, 0x47, 0x44,
665 0x53, 0x58, 0x18, 0xa2, 0x3a, 0x00, 0x01, 0x11, 0x71, 0x6b, 0x63, 0x6f, 0x6d, 0x70,
666 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x20, 0x32, 0x3a, 0x00, 0x01, 0x11, 0x73, 0xf6, 0x3a,
667 0x00, 0x47, 0x44, 0x52, 0x58, 0x40, 0xc7, 0x50, 0x09, 0xd0, 0xe0, 0xdd, 0x80, 0x77,
668 0xae, 0xa7, 0xc8, 0x88, 0x1e, 0x88, 0xd0, 0xc7, 0x0d, 0x7c, 0x49, 0xc5, 0xb5, 0x64,
669 0x32, 0x28, 0x2c, 0x48, 0x94, 0xc0, 0xd6, 0x7d, 0x9c, 0x86, 0xda, 0xf7, 0x98, 0xc7,
670 0xae, 0xa4, 0x0e, 0x61, 0xc8, 0xb0, 0x8b, 0x8a, 0xe4, 0xad, 0xcf, 0xcf, 0x6d, 0x60,
671 0x60, 0x31, 0xdd, 0xa7, 0x24, 0x9b, 0x27, 0x16, 0x31, 0x90, 0x80, 0x70, 0xc3, 0xba,
672 0x3a, 0x00, 0x47, 0x44, 0x54, 0x58, 0x40, 0xf8, 0x86, 0xc6, 0x94, 0xf9, 0x3f, 0x66,
673 0x3c, 0x43, 0x01, 0x29, 0x27, 0x8d, 0x3c, 0xb2, 0x11, 0xf2, 0x04, 0xb6, 0x67, 0x4f,
674 0x5f, 0x90, 0xcb, 0xc6, 0x73, 0xe6, 0x25, 0x14, 0x63, 0xa7, 0x95, 0x11, 0x0e, 0xa0,
675 0x1d, 0x3f, 0x6a, 0x58, 0x0a, 0x53, 0xaa, 0x68, 0x3b, 0x92, 0x64, 0x2b, 0x2e, 0x79,
676 0x80, 0x70, 0x0e, 0x41, 0xf5, 0xe9, 0x2a, 0x36, 0x0a, 0xa4, 0xe8, 0xb4, 0xe5, 0xdd,
677 0xa6, 0x3a, 0x00, 0x47, 0x44, 0x56, 0x41, 0x01, 0x3a, 0x00, 0x47, 0x44, 0x57, 0x58,
678 0x2d, 0xa5, 0x01, 0x01, 0x03, 0x27, 0x04, 0x81, 0x02, 0x20, 0x06, 0x21, 0x58, 0x20,
679 0x9e, 0x04, 0x11, 0x24, 0x34, 0xba, 0x40, 0xed, 0x86, 0xe9, 0x48, 0x70, 0x3b, 0xe7,
680 0x76, 0xfa, 0xc5, 0xf6, 0x6d, 0xab, 0x86, 0x12, 0x00, 0xbe, 0xc7, 0x00, 0x69, 0x0e,
681 0x97, 0x97, 0xa6, 0x12, 0x3a, 0x00, 0x47, 0x44, 0x58, 0x41, 0x20, 0x58, 0x40, 0xb7,
682 0x31, 0xd5, 0x4c, 0x7d, 0xf5, 0xd7, 0xb8, 0xb4, 0x4f, 0x93, 0x47, 0x2c, 0x3d, 0x50,
683 0xcc, 0xad, 0x28, 0x23, 0x68, 0xcf, 0xc2, 0x90, 0xd7, 0x02, 0x00, 0xd8, 0xf1, 0x00,
684 0x14, 0x03, 0x90, 0x9e, 0x0b, 0x91, 0xa7, 0x22, 0x28, 0xfe, 0x55, 0x42, 0x30, 0x93,
685 0x05, 0x66, 0xcd, 0xce, 0xb8, 0x48, 0x07, 0x56, 0x54, 0x67, 0xa5, 0xd7, 0xe3, 0x16,
686 0xd6, 0x75, 0x7c, 0x94, 0x98, 0x1b, 0x0b, 0x84, 0x43, 0xa1, 0x01, 0x27, 0xa0, 0x59,
687 0x01, 0x8d, 0xa9, 0x01, 0x78, 0x28, 0x32, 0x39, 0x65, 0x34, 0x62, 0x61, 0x63, 0x33,
688 0x30, 0x31, 0x65, 0x66, 0x36, 0x35, 0x61, 0x38, 0x31, 0x31, 0x62, 0x39, 0x39, 0x62,
689 0x30, 0x33, 0x64, 0x65, 0x39, 0x35, 0x34, 0x65, 0x61, 0x37, 0x36, 0x61, 0x38, 0x39,
690 0x31, 0x37, 0x38, 0x35, 0x02, 0x78, 0x28, 0x31, 0x38, 0x37, 0x36, 0x63, 0x61, 0x63,
691 0x34, 0x32, 0x33, 0x39, 0x35, 0x37, 0x66, 0x33, 0x62, 0x66, 0x62, 0x32, 0x62, 0x32,
692 0x63, 0x39, 0x33, 0x37, 0x64, 0x31, 0x34, 0x62, 0x62, 0x38, 0x30, 0x64, 0x30, 0x36,
693 0x37, 0x33, 0x65, 0x66, 0x66, 0x3a, 0x00, 0x47, 0x44, 0x50, 0x58, 0x40, 0xf4, 0x7d,
694 0x11, 0x21, 0xc1, 0x19, 0x57, 0x23, 0x08, 0x6e, 0x5f, 0xe4, 0x55, 0xc5, 0x08, 0x16,
695 0x40, 0x5f, 0x2a, 0x6f, 0x04, 0x1e, 0x6f, 0x22, 0xde, 0x53, 0xbd, 0x37, 0xe2, 0xfb,
696 0xb4, 0x0b, 0x65, 0xf4, 0xdc, 0xc9, 0xf4, 0xce, 0x2d, 0x82, 0x2a, 0xbc, 0xaf, 0x37,
697 0x80, 0x0b, 0x7f, 0xff, 0x3a, 0x98, 0x9c, 0xa7, 0x70, 0x4f, 0xbc, 0x59, 0x4f, 0x4e,
698 0xb1, 0x6d, 0xdf, 0x60, 0x39, 0x11, 0x3a, 0x00, 0x47, 0x44, 0x53, 0x58, 0x18, 0xa2,
699 0x3a, 0x00, 0x01, 0x11, 0x71, 0x6b, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e,
700 0x74, 0x20, 0x33, 0x3a, 0x00, 0x01, 0x11, 0x73, 0xf6, 0x3a, 0x00, 0x47, 0x44, 0x52,
701 0x58, 0x40, 0xa4, 0xd5, 0x6f, 0xc8, 0xd6, 0xc7, 0xe4, 0x22, 0xb4, 0x7a, 0x26, 0x49,
702 0xd5, 0xb4, 0xc1, 0xc6, 0x1b, 0xfa, 0x14, 0x8c, 0x49, 0x72, 0x2f, 0xfe, 0xbc, 0xc1,
703 0xc8, 0xc6, 0x65, 0x62, 0x86, 0xf7, 0xf2, 0x74, 0x45, 0x9b, 0x1a, 0xa0, 0x2b, 0xc4,
704 0x27, 0x13, 0xc5, 0xc3, 0xe5, 0x28, 0xc2, 0x16, 0xcd, 0x90, 0x6d, 0xa0, 0xf7, 0x27,
705 0x04, 0xa8, 0xa2, 0x62, 0xaa, 0x2c, 0x0c, 0x75, 0xd5, 0x9d, 0x3a, 0x00, 0x47, 0x44,
706 0x54, 0x58, 0x40, 0x1d, 0x92, 0x34, 0xfb, 0xfe, 0x74, 0xb7, 0xce, 0x3a, 0x95, 0x45,
707 0xe5, 0x3e, 0x1f, 0x5f, 0x18, 0x53, 0x5f, 0xe1, 0x85, 0xb0, 0x1d, 0xe3, 0x8d, 0x53,
708 0x77, 0xdc, 0x86, 0x32, 0x3d, 0x9b, 0xf9, 0xa5, 0x51, 0x17, 0x51, 0x9a, 0xd8, 0xa6,
709 0x7d, 0x45, 0x98, 0x47, 0xa2, 0x73, 0x54, 0x66, 0x28, 0x66, 0x92, 0x1d, 0x28, 0x8a,
710 0xe7, 0x5d, 0xb8, 0x96, 0x4b, 0x6a, 0x9d, 0xee, 0xc2, 0xe9, 0x20, 0x3a, 0x00, 0x47,
711 0x44, 0x56, 0x41, 0x01, 0x3a, 0x00, 0x47, 0x44, 0x57, 0x58, 0x2d, 0xa5, 0x01, 0x01,
712 0x03, 0x27, 0x04, 0x81, 0x02, 0x20, 0x06, 0x21, 0x58, 0x20, 0x4d, 0xf5, 0x61, 0x1e,
713 0xa6, 0x64, 0x74, 0x0b, 0x6c, 0x99, 0x8b, 0x6d, 0x34, 0x42, 0x21, 0xdd, 0x82, 0x26,
714 0x13, 0xb4, 0xf0, 0xbc, 0x9a, 0x0b, 0xf6, 0x56, 0xbd, 0x5d, 0xea, 0xd5, 0x07, 0x7a,
715 0x3a, 0x00, 0x47, 0x44, 0x58, 0x41, 0x20, 0x58, 0x40, 0x40, 0x4d, 0x09, 0x0d, 0x80,
716 0xba, 0x12, 0x94, 0x05, 0xfb, 0x1a, 0x23, 0xa3, 0xcb, 0x28, 0x6f, 0xd7, 0x29, 0x95,
717 0xda, 0x83, 0x07, 0x3c, 0xbe, 0x7c, 0x37, 0xeb, 0x9c, 0xb2, 0x77, 0x10, 0x3f, 0x6a,
718 0x41, 0x80, 0xce, 0x56, 0xb7, 0x55, 0x22, 0x81, 0x77, 0x2d, 0x3c, 0xf8, 0x16, 0x38,
719 0x49, 0xcc, 0x9a, 0xe8, 0x3a, 0x03, 0x33, 0x4c, 0xe6, 0x87, 0x72, 0xf6, 0x5a, 0x4a,
720 0x3f, 0x4e, 0x0a,
721 ],
722 )
723 .unwrap()
724 }
725 }
726