From 919c322f1336694e8064a1eb9e72f6b2bac082e0 Mon Sep 17 00:00:00 2001 From: Philip Chen Date: Wed, 1 Jul 2026 18:40:29 +0000 Subject: [PATCH 01/53] Use host monotonic clock for timestamp Previously, outgoing buffer timestamps in emulated_camera_mplane and emulated_camera_splane were calculated directly from the frame sequence index: tv_sec = (sequence + 1) / 1000 tv_usec = (sequence + 1) % 1000 This formula caused severe clock drift due to two issues: 1. Incorrect Time Scaling: sequence increments by 1 per frame. Dividing by 1000 caused tv_sec to advance by 1 second only after 1,000 frames (~33.3 seconds of real wall-clock time at 30 FPS). 2. Microsecond Miscalculation: In timeval, tv_usec is measured in microseconds (10^-6 s). Doing % 1000 without scaling caused the timestamp to advance by only 1 microsecond per frame. This change replaces the sequence-based calculation with the host's actual monotonic clock, avoiding timestamp drift and buffer rejections in the guest. Bug: b/474406105 --- .../emulated_camera_mplane/src/device.rs | 12 ++++++++++-- .../emulated_camera_splane/src/device.rs | 12 ++++++++++-- 2 files changed, 20 insertions(+), 4 deletions(-) diff --git a/base/cvd/cuttlefish/host/commands/vhost_user_media/emulated_camera_mplane/src/device.rs b/base/cvd/cuttlefish/host/commands/vhost_user_media/emulated_camera_mplane/src/device.rs index 09fed58e8e7..b5b0961fac6 100644 --- a/base/cvd/cuttlefish/host/commands/vhost_user_media/emulated_camera_mplane/src/device.rs +++ b/base/cvd/cuttlefish/host/commands/vhost_user_media/emulated_camera_mplane/src/device.rs @@ -123,9 +123,17 @@ impl Buffer { } } self.v4l2_buffer.set_sequence(sequence); + let mut ts = libc::timespec { + tv_sec: 0, + tv_nsec: 0, + }; + // SAFETY: clock_gettime is a standard POSIX libc call with a valid pointer. + unsafe { + libc::clock_gettime(libc::CLOCK_MONOTONIC, &mut ts); + } self.v4l2_buffer.set_timestamp(bindings::timeval { - tv_sec: (sequence + 1) as bindings::__time_t / 1000, - tv_usec: (sequence + 1) as bindings::__time_t % 1000, + tv_sec: ts.tv_sec as bindings::__time_t, + tv_usec: (ts.tv_nsec / 1000) as bindings::__time_t, }); flags &= !BufferFlags::QUEUED; } diff --git a/base/cvd/cuttlefish/host/commands/vhost_user_media/emulated_camera_splane/src/device.rs b/base/cvd/cuttlefish/host/commands/vhost_user_media/emulated_camera_splane/src/device.rs index 69133e21ddb..eae3f807dac 100644 --- a/base/cvd/cuttlefish/host/commands/vhost_user_media/emulated_camera_splane/src/device.rs +++ b/base/cvd/cuttlefish/host/commands/vhost_user_media/emulated_camera_splane/src/device.rs @@ -137,9 +137,17 @@ impl Buffer { } BufferState::Outgoing { sequence } => { self.v4l2_buffer.set_sequence(sequence); + let mut ts = libc::timespec { + tv_sec: 0, + tv_nsec: 0, + }; + // SAFETY: clock_gettime is a standard POSIX libc call with a valid pointer. + unsafe { + libc::clock_gettime(libc::CLOCK_MONOTONIC, &mut ts); + } self.v4l2_buffer.set_timestamp(bindings::timeval { - tv_sec: (sequence + 1) as bindings::__time_t / 1000, - tv_usec: (sequence + 1) as bindings::__time_t % 1000, + tv_sec: ts.tv_sec as bindings::__time_t, + tv_usec: (ts.tv_nsec / 1000) as bindings::__time_t, }); Self::unset_flag(&mut flags, BufferFlags::QUEUED); } From 53c93a5d858eb0f48c75ea609a045d643b1403ed Mon Sep 17 00:00:00 2001 From: Sergio Andres Rodriguez Orama Date: Fri, 10 Jul 2026 15:24:08 -0400 Subject: [PATCH 02/53] Implement custom lens_facing control for emulated_camera_mplane. Bug: b/502639876 Test: cvd create --media="type=v4l2_emulated_camera_mplane,lens_facing=FRONT" && adb shell "su 0 v4l2-ctl -d /dev/video1 --list-ctrls" --- .../emulated_camera_mplane/src/device.rs | 174 +++++++++++++++++- .../emulated_camera_mplane/src/main.rs | 19 +- 2 files changed, 189 insertions(+), 4 deletions(-) diff --git a/base/cvd/cuttlefish/host/commands/vhost_user_media/emulated_camera_mplane/src/device.rs b/base/cvd/cuttlefish/host/commands/vhost_user_media/emulated_camera_mplane/src/device.rs index b5b0961fac6..d81245ac522 100644 --- a/base/cvd/cuttlefish/host/commands/vhost_user_media/emulated_camera_mplane/src/device.rs +++ b/base/cvd/cuttlefish/host/commands/vhost_user_media/emulated_camera_mplane/src/device.rs @@ -30,6 +30,11 @@ use v4l2r::bindings::v4l2_requestbuffers; use v4l2r::ioctl::BufferCapabilities; use v4l2r::ioctl::BufferField; use v4l2r::ioctl::BufferFlags; +use v4l2r::ioctl::CtrlId; +use v4l2r::ioctl::CtrlWhich; +use v4l2r::ioctl::EventType as V4l2EventType; +use v4l2r::ioctl::QueryCtrlFlags; +use v4l2r::ioctl::SubscribeEventFlags; use v4l2r::ioctl::V4l2Buffer; use v4l2r::ioctl::V4l2PlanesWithBackingMut; use v4l2r::memory::MemoryType; @@ -45,10 +50,33 @@ use virtio_media::ioctl::virtio_media_dispatch_ioctl; use virtio_media::memfd::MemFdBuffer; use virtio_media::mmap::MmapMappingManager; use virtio_media::protocol::DequeueBufferEvent; +use virtio_media::protocol::SessionEvent; use virtio_media::protocol::SgEntry; use virtio_media::protocol::V4l2Event; use virtio_media::protocol::V4l2Ioctl; use virtio_media::protocol::VIRTIO_MEDIA_MMAP_FLAG_RW; +use std::str::FromStr; + +/// https://developer.android.com/reference/android/hardware/camera2/CameraMetadata#LENS_FACING_FRONT +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum LensFacing { + Front = 0, + Back = 1, + External = 2, +} + +impl FromStr for LensFacing { + type Err = String; + + fn from_str(s: &str) -> Result { + match s { + "FRONT" => Ok(LensFacing::Front), + "BACK" => Ok(LensFacing::Back), + "EXTERNAL" => Ok(LensFacing::External), + _ => Err(format!("Invalid lens facing: {}. Expected FRONT, BACK, or EXTERNAL", s)), + } + } +} /// Current status of a buffer. #[derive(Debug, PartialEq, Eq)] @@ -243,6 +271,8 @@ pub struct EmulatedCamera, + /// Lens facing configuration. + lens_facing: LensFacing, } impl EmulatedCamera @@ -250,11 +280,31 @@ where Q: VirtioMediaEventQueue, HM: VirtioMediaHostMemoryMapper, { - pub fn new(evt_queue: Q, mapper: HM) -> Self { + pub fn new(evt_queue: Q, mapper: HM, lens_facing: LensFacing) -> Self { Self { evt_queue, mmap_manager: MmapMappingManager::from(mapper), active_session: None, + lens_facing, + } + } + + fn lens_facing_query_ext_ctrl(&self) -> bindings::v4l2_query_ext_ctrl { + let name_str = "LENS_FACING"; + let mut name = [0u8; 32]; + name[0..name_str.len()].copy_from_slice(name_str.as_bytes()); + bindings::v4l2_query_ext_ctrl { + id: CID_LENS_FACING, + type_: bindings::v4l2_ctrl_type_V4L2_CTRL_TYPE_INTEGER, + name: name.map(|b| b as i8), + minimum: LensFacing::Front as i64, + maximum: LensFacing::External as i64, + step: 1, + default_value: self.lens_facing as i64, + flags: bindings::V4L2_CTRL_FLAG_READ_ONLY, + elems: 1, + elem_size: std::mem::size_of::() as u32, + ..Default::default() } } } @@ -337,6 +387,10 @@ where } } +// Use an offset for virtio-media custom camera class control id values. +const CID_OFFSET: u32 = bindings::V4L2_CID_CAMERA_CLASS_BASE + 0x100; +const CID_LENS_FACING: u32 = CID_OFFSET + 1; + const PIXELFORMAT: u32 = PixelFormat::from_fourcc(b"YM12").to_u32(); const WIDTH: u32 = 640; const HEIGHT: u32 = 480; @@ -776,4 +830,122 @@ where ..Default::default() }) } + + /// https://www.kernel.org/doc/html/latest/userspace-api/media/v4l/vidioc-queryctrl.html#control-flags + fn query_ext_ctrl( + &mut self, + _session: &Self::Session, + id: CtrlId, + flags: QueryCtrlFlags, + ) -> IoctlResult { + let id: u32 = unsafe { std::mem::transmute(id) }; + // If V4L2_CTRL_FLAG_NEXT_CTRL present returns the first control with a higher ID. + if flags.contains(QueryCtrlFlags::NEXT) { + if id < CID_LENS_FACING { + return Ok(self.lens_facing_query_ext_ctrl()); + } + } else if id == CID_LENS_FACING { + return Ok(self.lens_facing_query_ext_ctrl()); + } + return Err(libc::EINVAL); + } + + fn g_ext_ctrls( + &mut self, + _session: &Self::Session, + _which: CtrlWhich, + ctrls: &mut bindings::v4l2_ext_controls, + ctrl_array: &mut Vec, + _user_regions: Vec>, + ) -> IoctlResult<()> { + for ctrl in ctrl_array { + match ctrl.id { + CID_LENS_FACING => { + ctrl.__bindgen_anon_1.value = self.lens_facing as i32; + } + _ => { + ctrls.error_idx = ctrls.count; + return Err(libc::EINVAL); + } + } + } + Ok(()) + } + + fn try_ext_ctrls( + &mut self, + _session: &Self::Session, + _which: CtrlWhich, + ctrls: &mut bindings::v4l2_ext_controls, + ctrl_array: &mut Vec, + _user_regions: Vec>, + ) -> IoctlResult<()> { + for (idx, ctrl) in ctrl_array.iter_mut().enumerate() { + ctrls.error_idx = idx as u32; + let err_code = match ctrl.id { + CID_LENS_FACING => libc::EACCES, + _ => libc::EINVAL, + }; + return Err(err_code); + } + Ok(()) + } + + fn s_ext_ctrls( + &mut self, + _session: &mut Self::Session, + _which: CtrlWhich, + ctrls: &mut bindings::v4l2_ext_controls, + ctrl_array: &mut Vec, + _user_regions: Vec>, + ) -> IoctlResult<()> { + for ctrl in ctrl_array { + ctrls.error_idx = ctrls.count; + let err_code = match ctrl.id { + CID_LENS_FACING => libc::EACCES, + _ => libc::EINVAL, + }; + return Err(err_code); + } + Ok(()) + } + + fn subscribe_event( + &mut self, + session: &mut Self::Session, + event: V4l2EventType, + flags: SubscribeEventFlags, + ) -> IoctlResult<()> { + if !flags.contains(SubscribeEventFlags::SEND_INITIAL) { + return Err(libc::EINVAL); + } + match event { + V4l2EventType::Ctrl(id) => match id { + CID_LENS_FACING => { + let ctrl_event = bindings::v4l2_event { + type_: bindings::V4L2_EVENT_CTRL, + id: CID_LENS_FACING, + ..Default::default() + }; + self.evt_queue + .send_event(V4l2Event::Event(SessionEvent::new(session.id, ctrl_event))); + Ok(()) + } + _ => Err(libc::EINVAL), + }, + _ => Err(libc::EINVAL), + } + } + + fn unsubscribe_event( + &mut self, + _session: &mut Self::Session, + event: bindings::v4l2_event_subscription, + ) -> IoctlResult<()> { + return if event.type_ == bindings::V4L2_EVENT_CTRL && event.id == CID_LENS_FACING { + Ok(()) + } else { + Err(libc::EINVAL) + }; + } } diff --git a/base/cvd/cuttlefish/host/commands/vhost_user_media/emulated_camera_mplane/src/main.rs b/base/cvd/cuttlefish/host/commands/vhost_user_media/emulated_camera_mplane/src/main.rs index 5ad797021df..dfd44608c19 100644 --- a/base/cvd/cuttlefish/host/commands/vhost_user_media/emulated_camera_mplane/src/main.rs +++ b/base/cvd/cuttlefish/host/commands/vhost_user_media/emulated_camera_mplane/src/main.rs @@ -24,9 +24,12 @@ use virtio_media::protocol::VirtioMediaDeviceConfig; use vm_memory::{GuestMemoryAtomic, GuestMemoryMmap}; mod device; +use device::LensFacing; #[derive(Debug, Error)] pub(crate) enum Error { + #[error("Invalid argument: {0}")] + InvalidArgument(String), #[error("Could not create daemon: {0}")] CouldNotCreateDaemon(vhost_user_backend::Error), #[error("Fatal error: {0}")] @@ -44,19 +47,26 @@ struct CmdLineArgs { /// Log verbosity, one of Off, Error, Warning, Info, Debug, Trace. #[clap(short, long, default_value_t = log::LevelFilter::Debug)] verbosity: log::LevelFilter, + /// Lens facing configuration: FRONT, BACK, or EXTERNAL. + #[clap(long, value_name = "LENS_FACING", default_value = "BACK")] + lens_facing: String, } #[derive(PartialEq, Debug)] struct Config { socket_path: PathBuf, + lens_facing: LensFacing, } impl TryFrom for Config { type Error = Error; fn try_from(args: CmdLineArgs) -> Result { + let lens_facing = args.lens_facing.parse::() + .map_err(Error::InvalidArgument)?; Ok(Config { socket_path: args.socket_path, + lens_facing, }) } } @@ -80,14 +90,17 @@ fn start_backend(config: Config) -> Result<()> { // across VMs restarts rather than having to manually start the binary again. loop { use virtio_media::v4l2r::ioctl::Capabilities; - let config = VirtioMediaDeviceConfig { + let device_config = VirtioMediaDeviceConfig { device_caps: (Capabilities::VIDEO_CAPTURE_MPLANE | Capabilities::STREAMING).bits(), device_type: VFL_TYPE_VIDEO, card, }; + let lens_facing = config.lens_facing; let backend = Arc::new(RwLock::new(VhuMediaBackend::new( - config, - |event_queue, host_mapper| crate::device::EmulatedCamera::new(event_queue, host_mapper), + device_config, + move |event_queue, host_mapper| { + crate::device::EmulatedCamera::new(event_queue, host_mapper, lens_facing) + }, ))); let mut daemon = VhostUserDaemon::new( String::from("vhost-user-media-backend"), From 84bcd4c774d01965776c7e786ae1ee912e566db9 Mon Sep 17 00:00:00 2001 From: Sergio Andres Rodriguez Orama Date: Mon, 13 Jul 2026 16:08:12 -0400 Subject: [PATCH 03/53] Default lens_facing to EXTERNAL. - Avoid breaking existing virtio-media workflows for auto and XR targets. Bug: b/527931134 --- .../vhost_user_media/emulated_camera_mplane/src/main.rs | 2 +- .../vhost_user_media/emulated_camera_splane/src/main.rs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/base/cvd/cuttlefish/host/commands/vhost_user_media/emulated_camera_mplane/src/main.rs b/base/cvd/cuttlefish/host/commands/vhost_user_media/emulated_camera_mplane/src/main.rs index dfd44608c19..1ed6ad21c4d 100644 --- a/base/cvd/cuttlefish/host/commands/vhost_user_media/emulated_camera_mplane/src/main.rs +++ b/base/cvd/cuttlefish/host/commands/vhost_user_media/emulated_camera_mplane/src/main.rs @@ -48,7 +48,7 @@ struct CmdLineArgs { #[clap(short, long, default_value_t = log::LevelFilter::Debug)] verbosity: log::LevelFilter, /// Lens facing configuration: FRONT, BACK, or EXTERNAL. - #[clap(long, value_name = "LENS_FACING", default_value = "BACK")] + #[clap(long, value_name = "LENS_FACING", default_value = "EXTERNAL")] lens_facing: String, } diff --git a/base/cvd/cuttlefish/host/commands/vhost_user_media/emulated_camera_splane/src/main.rs b/base/cvd/cuttlefish/host/commands/vhost_user_media/emulated_camera_splane/src/main.rs index 175d8dc61a6..76834e66b99 100644 --- a/base/cvd/cuttlefish/host/commands/vhost_user_media/emulated_camera_splane/src/main.rs +++ b/base/cvd/cuttlefish/host/commands/vhost_user_media/emulated_camera_splane/src/main.rs @@ -37,7 +37,7 @@ struct CmdLineArgs { #[clap(short, long, default_value_t = log::LevelFilter::Debug)] verbosity: log::LevelFilter, /// Lens facing configuration: FRONT, BACK, or EXTERNAL. - #[clap(long, value_name = "LENS_FACING", default_value = "BACK")] + #[clap(long, value_name = "LENS_FACING", default_value = "EXTERNAL")] lens_facing: String, } From 6a2996852cabf3dc875f81fa873cea191bd4e843 Mon Sep 17 00:00:00 2001 From: Sergio Andres Rodriguez Orama Date: Mon, 27 Jul 2026 14:11:04 -0400 Subject: [PATCH 04/53] Emulate signal gain for emulated_camera_mplane. Interact with the control: ``` adb shell "su 0 v4l2-ctl -d /dev/video1 -l" adb shell "su 0 v4l2-ctl -d /dev/video1 --set-ctrl=gain=500" ``` Introduce CameraControls, to manage the state of control values. Bug: b/539617743 Assisted-by: Jetski:Gemini 3.5 Flash --- .../emulated_camera_mplane/src/device.rs | 330 ++++++++++++++++-- 1 file changed, 297 insertions(+), 33 deletions(-) diff --git a/base/cvd/cuttlefish/host/commands/vhost_user_media/emulated_camera_mplane/src/device.rs b/base/cvd/cuttlefish/host/commands/vhost_user_media/emulated_camera_mplane/src/device.rs index d81245ac522..6986837e048 100644 --- a/base/cvd/cuttlefish/host/commands/vhost_user_media/emulated_camera_mplane/src/device.rs +++ b/base/cvd/cuttlefish/host/commands/vhost_user_media/emulated_camera_mplane/src/device.rs @@ -57,6 +57,14 @@ use virtio_media::protocol::V4l2Ioctl; use virtio_media::protocol::VIRTIO_MEDIA_MMAP_FLAG_RW; use std::str::FromStr; +/// Rust equivalent of the V4L2_CTRL_ID2WHICH C preprocessor macro. +/// Extracts the control class ID from a control ID by masking out the lower 16 bits +/// and any reserved top bits (uses mask 0x0fff0000). +/// See: https://www.kernel.org/doc/html/latest/userspace-api/media/v4l/control.html +const fn v4l2_ctrl_id2which(id: u32) -> u32 { + id & 0x0fff0000 +} + /// https://developer.android.com/reference/android/hardware/camera2/CameraMetadata#LENS_FACING_FRONT #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum LensFacing { @@ -78,6 +86,49 @@ impl FromStr for LensFacing { } } +/// Encapsulates the camera gain value. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct Gain(i32); + +impl Gain { + pub const MIN: i32 = 100; + pub const MAX: i32 = 1600; + pub const DEFAULT: i32 = 100; + + pub fn new(value: i32) -> Result { + if value < Self::MIN || value > Self::MAX { + Err(libc::ERANGE) + } else { + Ok(Gain(value)) + } + } + + pub fn value(&self) -> i32 { + self.0 + } +} + +impl Default for Gain { + fn default() -> Self { + Gain(Self::DEFAULT) + } +} + +/// State of all camera controls. +struct CameraControls { + lens_facing: LensFacing, + gain: Gain, +} + +impl CameraControls { + fn new(lens_facing: LensFacing) -> Self { + Self { + lens_facing, + gain: Gain::default(), + } + } +} + /// Current status of a buffer. #[derive(Debug, PartialEq, Eq)] enum BufferState { @@ -194,6 +245,7 @@ impl VirtioMediaDeviceSession for EmulatedCameraSession { impl EmulatedCameraSession { fn write_pattern( iteration: u64, + controls: &CameraControls, mut sink_y: WY, mut sink_u: WU, mut sink_v: WV, @@ -201,7 +253,12 @@ impl EmulatedCameraSession { let mut writer_y = BufWriter::new(&mut sink_y); let mut writer_u = BufWriter::new(&mut sink_u); let mut writer_v = BufWriter::new(&mut sink_v); - let y = (iteration % 256) as u8; + // The base Y (luma) value changes over iterations to create a moving pattern. + let base_y = (iteration % 256) as u8; + // Apply gain to the luma channel. + // Gain::MIN (100) represents 1.0x gain. Higher values scale the brightness. + // We clamp the result to 255.0 to avoid overflow. + let y = ((base_y as f32) * (controls.gain.value() as f32 / Gain::MIN as f32)).min(255.0) as u8; let u = ((iteration + 64) % 256) as u8; let v = ((iteration + 128) % 256) as u8; for _ in 0..(WIDTH * HEIGHT) { @@ -220,6 +277,7 @@ impl EmulatedCameraSession { fn process_queued_buffers( &mut self, evt_queue: &mut Q, + controls: &CameraControls, ) -> IoctlResult<()> { while let Some(buf_id) = self.queued_buffers.pop_front() { let iteration = self.iteration; @@ -235,6 +293,7 @@ impl EmulatedCameraSession { Self::write_pattern( iteration, + controls, buffer.planes[0].fd.as_file(), buffer.planes[1].fd.as_file(), buffer.planes[2].fd.as_file(), @@ -271,8 +330,8 @@ pub struct EmulatedCamera, - /// Lens facing configuration. - lens_facing: LensFacing, + /// Camera controls. + controls: CameraControls, } impl EmulatedCamera @@ -285,7 +344,7 @@ where evt_queue, mmap_manager: MmapMappingManager::from(mapper), active_session: None, - lens_facing, + controls: CameraControls::new(lens_facing), } } @@ -300,13 +359,60 @@ where minimum: LensFacing::Front as i64, maximum: LensFacing::External as i64, step: 1, - default_value: self.lens_facing as i64, + default_value: self.controls.lens_facing as i64, flags: bindings::V4L2_CTRL_FLAG_READ_ONLY, elems: 1, elem_size: std::mem::size_of::() as u32, ..Default::default() } } + + fn gain_query_ext_ctrl(&self) -> bindings::v4l2_query_ext_ctrl { + let name_str = "Gain"; + let mut name = [0u8; 32]; + name[0..name_str.len()].copy_from_slice(name_str.as_bytes()); + bindings::v4l2_query_ext_ctrl { + id: bindings::V4L2_CID_GAIN, + type_: bindings::v4l2_ctrl_type_V4L2_CTRL_TYPE_INTEGER, + name: name.map(|b| b as i8), + minimum: Gain::MIN as i64, + maximum: Gain::MAX as i64, + step: 1, + default_value: Gain::DEFAULT as i64, + flags: 0, + elems: 1, + elem_size: std::mem::size_of::() as u32, + ..Default::default() + } + } + + fn user_class_query_ext_ctrl(&self) -> bindings::v4l2_query_ext_ctrl { + let name_str = "User Controls"; + let mut name = [0u8; 32]; + name[0..name_str.len()].copy_from_slice(name_str.as_bytes()); + bindings::v4l2_query_ext_ctrl { + id: bindings::V4L2_CID_USER_CLASS, + type_: bindings::v4l2_ctrl_type_V4L2_CTRL_TYPE_CTRL_CLASS, + name: name.map(|b| b as i8), + // V4L2 standard requires control class headers to be marked as both RO and WO. + flags: bindings::V4L2_CTRL_FLAG_READ_ONLY | bindings::V4L2_CTRL_FLAG_WRITE_ONLY, + ..Default::default() + } + } + + fn camera_class_query_ext_ctrl(&self) -> bindings::v4l2_query_ext_ctrl { + let name_str = "Camera Controls"; + let mut name = [0u8; 32]; + name[0..name_str.len()].copy_from_slice(name_str.as_bytes()); + bindings::v4l2_query_ext_ctrl { + id: bindings::V4L2_CID_CAMERA_CLASS, + type_: bindings::v4l2_ctrl_type_V4L2_CTRL_TYPE_CTRL_CLASS, + name: name.map(|b| b as i8), + // V4L2 standard requires control class headers to be marked as both RO and WO. + flags: bindings::V4L2_CTRL_FLAG_READ_ONLY | bindings::V4L2_CTRL_FLAG_WRITE_ONLY, + ..Default::default() + } + } } impl VirtioMediaDevice for EmulatedCamera @@ -724,7 +830,7 @@ where let buffer = host_buffer.v4l2_buffer.clone(); if session.streaming { - session.process_queued_buffers(&mut self.evt_queue)?; + session.process_queued_buffers(&mut self.evt_queue, &self.controls)?; } Ok(buffer) @@ -736,7 +842,7 @@ where } session.streaming = true; - session.process_queued_buffers(&mut self.evt_queue)?; + session.process_queued_buffers(&mut self.evt_queue, &self.controls)?; Ok(()) } @@ -839,13 +945,26 @@ where flags: QueryCtrlFlags, ) -> IoctlResult { let id: u32 = unsafe { std::mem::transmute(id) }; - // If V4L2_CTRL_FLAG_NEXT_CTRL present returns the first control with a higher ID. if flags.contains(QueryCtrlFlags::NEXT) { - if id < CID_LENS_FACING { + if id < bindings::V4L2_CID_USER_CLASS { + return Ok(self.user_class_query_ext_ctrl()); + } else if id < bindings::V4L2_CID_GAIN { + return Ok(self.gain_query_ext_ctrl()); + } else if id < bindings::V4L2_CID_CAMERA_CLASS { + return Ok(self.camera_class_query_ext_ctrl()); + } else if id < CID_LENS_FACING { + return Ok(self.lens_facing_query_ext_ctrl()); + } + } else { + if id == bindings::V4L2_CID_USER_CLASS { + return Ok(self.user_class_query_ext_ctrl()); + } else if id == bindings::V4L2_CID_GAIN { + return Ok(self.gain_query_ext_ctrl()); + } else if id == bindings::V4L2_CID_CAMERA_CLASS { + return Ok(self.camera_class_query_ext_ctrl()); + } else if id == CID_LENS_FACING { return Ok(self.lens_facing_query_ext_ctrl()); } - } else if id == CID_LENS_FACING { - return Ok(self.lens_facing_query_ext_ctrl()); } return Err(libc::EINVAL); } @@ -853,15 +972,51 @@ where fn g_ext_ctrls( &mut self, _session: &Self::Session, - _which: CtrlWhich, + which: CtrlWhich, ctrls: &mut bindings::v4l2_ext_controls, ctrl_array: &mut Vec, _user_regions: Vec>, ) -> IoctlResult<()> { - for ctrl in ctrl_array { + // Validate control class. Also handles class support queries when count == 0. + match which { + CtrlWhich::Current | CtrlWhich::Default => {} + CtrlWhich::Class(class) => { + if class != bindings::V4L2_CTRL_CLASS_USER && class != bindings::V4L2_CTRL_CLASS_CAMERA { + ctrls.error_idx = ctrls.count; + return Err(libc::EINVAL); + } + } + _ => { + ctrls.error_idx = ctrls.count; + return Err(libc::EINVAL); + } + } + + // Ensure all requested controls belong to the selected class. + if let CtrlWhich::Class(class_id) = which { + for (idx, ctrl) in ctrl_array.iter().enumerate() { + if v4l2_ctrl_id2which(ctrl.id) != class_id { + ctrls.error_idx = ctrls.count; + return Err(libc::EINVAL); + } + } + } + + // Process controls. Class controls are write-only headers and must fail on read. + for (idx, ctrl) in ctrl_array.iter_mut().enumerate() { match ctrl.id { + bindings::V4L2_CID_USER_CLASS | bindings::V4L2_CID_CAMERA_CLASS => { + ctrls.error_idx = ctrls.count; + return Err(libc::EACCES); + } + bindings::V4L2_CID_GAIN => { + ctrl.__bindgen_anon_1.value = match which { + CtrlWhich::Default => Gain::DEFAULT, + _ => self.controls.gain.value(), + }; + } CID_LENS_FACING => { - ctrl.__bindgen_anon_1.value = self.lens_facing as i32; + ctrl.__bindgen_anon_1.value = self.controls.lens_facing as i32; } _ => { ctrls.error_idx = ctrls.count; @@ -869,44 +1024,144 @@ where } } } + ctrls.error_idx = ctrls.count; Ok(()) } fn try_ext_ctrls( &mut self, _session: &Self::Session, - _which: CtrlWhich, + which: CtrlWhich, ctrls: &mut bindings::v4l2_ext_controls, ctrl_array: &mut Vec, _user_regions: Vec>, ) -> IoctlResult<()> { + // Validate control class. Setting defaults is not allowed for TRY/SET. + match which { + CtrlWhich::Current => {} + CtrlWhich::Class(class) => { + if class != bindings::V4L2_CTRL_CLASS_USER && class != bindings::V4L2_CTRL_CLASS_CAMERA { + ctrls.error_idx = ctrls.count; + return Err(libc::EINVAL); + } + } + _ => { + ctrls.error_idx = ctrls.count; + return Err(libc::EINVAL); + } + } + + // Ensure all requested controls belong to the selected class. + if let CtrlWhich::Class(class_id) = which { + for (idx, ctrl) in ctrl_array.iter().enumerate() { + if v4l2_ctrl_id2which(ctrl.id) != class_id { + ctrls.error_idx = idx as u32; + return Err(libc::EINVAL); + } + } + } + + // Validate control values. Class controls are read-only headers and must fail on write/try. for (idx, ctrl) in ctrl_array.iter_mut().enumerate() { - ctrls.error_idx = idx as u32; - let err_code = match ctrl.id { - CID_LENS_FACING => libc::EACCES, - _ => libc::EINVAL, - }; - return Err(err_code); + match ctrl.id { + bindings::V4L2_CID_USER_CLASS | bindings::V4L2_CID_CAMERA_CLASS => { + ctrls.error_idx = idx as u32; + return Err(libc::EACCES); + } + bindings::V4L2_CID_GAIN => { + let value = unsafe { ctrl.__bindgen_anon_1.value }; + if let Err(err) = Gain::new(value) { + ctrls.error_idx = idx as u32; + return Err(err); + } + } + CID_LENS_FACING => { + ctrls.error_idx = idx as u32; + return Err(libc::EACCES); + } + _ => { + ctrls.error_idx = idx as u32; + return Err(libc::EINVAL); + } + } } + ctrls.error_idx = ctrls.count; Ok(()) } fn s_ext_ctrls( &mut self, - _session: &mut Self::Session, - _which: CtrlWhich, + session: &mut Self::Session, + which: CtrlWhich, ctrls: &mut bindings::v4l2_ext_controls, ctrl_array: &mut Vec, _user_regions: Vec>, ) -> IoctlResult<()> { - for ctrl in ctrl_array { - ctrls.error_idx = ctrls.count; - let err_code = match ctrl.id { - CID_LENS_FACING => libc::EACCES, - _ => libc::EINVAL, - }; - return Err(err_code); + // Validate control class. Setting defaults is not allowed for TRY/SET. + match which { + CtrlWhich::Current => {} + CtrlWhich::Class(class) => { + if class != bindings::V4L2_CTRL_CLASS_USER && class != bindings::V4L2_CTRL_CLASS_CAMERA { + ctrls.error_idx = ctrls.count; + return Err(libc::EINVAL); + } + } + _ => { + ctrls.error_idx = ctrls.count; + return Err(libc::EINVAL); + } + } + + // Ensure all requested controls belong to the selected class. + if let CtrlWhich::Class(class_id) = which { + for (idx, ctrl) in ctrl_array.iter().enumerate() { + if v4l2_ctrl_id2which(ctrl.id) != class_id { + ctrls.error_idx = ctrls.count; + return Err(libc::EINVAL); + } + } + } + + // Apply control values. Class controls are read-only headers and must fail on write/try. + for (idx, ctrl) in ctrl_array.iter_mut().enumerate() { + match ctrl.id { + bindings::V4L2_CID_USER_CLASS | bindings::V4L2_CID_CAMERA_CLASS => { + ctrls.error_idx = ctrls.count; + return Err(libc::EACCES); + } + bindings::V4L2_CID_GAIN => { + let value = unsafe { ctrl.__bindgen_anon_1.value }; + match Gain::new(value) { + Ok(gain) => { + if self.controls.gain != gain { + self.controls.gain = gain; + let ctrl_event = bindings::v4l2_event { + type_: bindings::V4L2_EVENT_CTRL, + id: bindings::V4L2_CID_GAIN, + ..Default::default() + }; + self.evt_queue.send_event(V4l2Event::Event(SessionEvent::new( + session.id, ctrl_event, + ))); + } + } + Err(err) => { + ctrls.error_idx = ctrls.count; + return Err(err); + } + } + } + CID_LENS_FACING => { + ctrls.error_idx = ctrls.count; + return Err(libc::EACCES); + } + _ => { + ctrls.error_idx = ctrls.count; + return Err(libc::EINVAL); + } + } } + ctrls.error_idx = ctrls.count; Ok(()) } @@ -921,16 +1176,20 @@ where } match event { V4l2EventType::Ctrl(id) => match id { - CID_LENS_FACING => { + CID_LENS_FACING | bindings::V4L2_CID_GAIN => { let ctrl_event = bindings::v4l2_event { type_: bindings::V4L2_EVENT_CTRL, - id: CID_LENS_FACING, + id, ..Default::default() }; self.evt_queue .send_event(V4l2Event::Event(SessionEvent::new(session.id, ctrl_event))); Ok(()) } + bindings::V4L2_CID_USER_CLASS | bindings::V4L2_CID_CAMERA_CLASS => { + // Subscription succeeds, but we do not send any initial event. + Ok(()) + } _ => Err(libc::EINVAL), }, _ => Err(libc::EINVAL), @@ -942,7 +1201,12 @@ where _session: &mut Self::Session, event: bindings::v4l2_event_subscription, ) -> IoctlResult<()> { - return if event.type_ == bindings::V4L2_EVENT_CTRL && event.id == CID_LENS_FACING { + return if event.type_ == bindings::V4L2_EVENT_CTRL + && (event.id == CID_LENS_FACING + || event.id == bindings::V4L2_CID_GAIN + || event.id == bindings::V4L2_CID_USER_CLASS + || event.id == bindings::V4L2_CID_CAMERA_CLASS) + { Ok(()) } else { Err(libc::EINVAL) From edb4b50a21e69717b8c0805aeafdd2e6af80347d Mon Sep 17 00:00:00 2001 From: Roman Kiryanov Date: Thu, 23 Jul 2026 01:40:34 +0000 Subject: [PATCH 05/53] modem_simulator: prevent unhandled exceptions for strings shorter than 2 std::string::compare > The overloads taking parameters named pos1 or pos2 > throws std::out_of_range if the argument is out of range. Bug: 509614113 Signed-off-by: Roman Kiryanov --- .../host/commands/modem_simulator/modem_service.cpp | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/base/cvd/cuttlefish/host/commands/modem_simulator/modem_service.cpp b/base/cvd/cuttlefish/host/commands/modem_simulator/modem_service.cpp index 54151593be2..e5806c32371 100644 --- a/base/cvd/cuttlefish/host/commands/modem_simulator/modem_service.cpp +++ b/base/cvd/cuttlefish/host/commands/modem_simulator/modem_service.cpp @@ -34,14 +34,13 @@ CommandHandler::CommandHandler(const std::string& command, p_func handler) p_command_handler(handler) {} int CommandHandler::Compare(const std::string& command) const { - int result = -1; - if (match_mode == PARTIAL_MATCH) { - result = - command.compare(2, command_prefix.size(), command_prefix); // skip "AT" - } else { - result = command.compare(2, command.size(), command_prefix); + if (command.size() < 2) { // the "AT" prefix + return -1; } - return result; + + return (match_mode == PARTIAL_MATCH) + ? command.compare(2, command_prefix.size(), command_prefix) + : command.compare(2, command.size(), command_prefix); } void CommandHandler::HandleCommand(const Client& client, From 89c61d3b2edde91d7140b3a482feef0582a4149e Mon Sep 17 00:00:00 2001 From: Roman Kiryanov Date: Thu, 23 Jul 2026 17:20:45 +0000 Subject: [PATCH 06/53] modem_simulator: prevent unhandled exceptions for incorrect input std::stoi: > std::invalid_argument if no conversion could be performed. > std::out_of_range if the converted value would fall out of the range Bug: 509614113 Signed-off-by: Roman Kiryanov --- .../cuttlefish/host/commands/modem_simulator/call_service.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/base/cvd/cuttlefish/host/commands/modem_simulator/call_service.cpp b/base/cvd/cuttlefish/host/commands/modem_simulator/call_service.cpp index 554878d4ff0..248ca45b5c6 100644 --- a/base/cvd/cuttlefish/host/commands/modem_simulator/call_service.cpp +++ b/base/cvd/cuttlefish/host/commands/modem_simulator/call_service.cpp @@ -400,8 +400,8 @@ void CallService::HandleHangup(const Client& client, CommandParser cmd(command); cmd.SkipPrefix(); - std::string action(*cmd); - int n = std::stoi(action.substr(0, 1)); + const std::string action(*cmd); + const int n = action.empty() ? -1 : (action[0] - '0'); int index = -1; if (cmd->length() > 1) { index = std::stoi(action.substr(1)); From 11153035381a3657ea92bed9a088b9f5a228a1d3 Mon Sep 17 00:00:00 2001 From: Roman Kiryanov Date: Thu, 23 Jul 2026 17:28:59 +0000 Subject: [PATCH 07/53] modem_simulator: fix the possible OOB if the buffer is not null terminated If the `Read` call fills the whole buffer, `commands.append(buffer.data())` with no zero characters will read past the buffer. If the `Read` produces data with zero characters in the middle, it will cause a loss of data. Bug: 509614113 Signed-off-by: Roman Kiryanov --- .../commands/modem_simulator/channel_monitor.cpp | 16 ++++++---------- 1 file changed, 6 insertions(+), 10 deletions(-) diff --git a/base/cvd/cuttlefish/host/commands/modem_simulator/channel_monitor.cpp b/base/cvd/cuttlefish/host/commands/modem_simulator/channel_monitor.cpp index b8f64818680..5a68a543993 100644 --- a/base/cvd/cuttlefish/host/commands/modem_simulator/channel_monitor.cpp +++ b/base/cvd/cuttlefish/host/commands/modem_simulator/channel_monitor.cpp @@ -81,8 +81,8 @@ void ChannelMonitor::AcceptIncomingConnection() { } void ChannelMonitor::ReadCommand(Client& client) { - std::vector buffer(kMaxCommandLength); - auto bytes_read = client.client_read_fd_->Read(buffer.data(), buffer.size()); + char buffer[kMaxCommandLength]; + auto bytes_read = client.client_read_fd_->Read(buffer, kMaxCommandLength); if (bytes_read <= 0) { if (errno == EAGAIN && client.type == Client::REMOTE && client.first_read_command_) { @@ -105,13 +105,9 @@ void ChannelMonitor::ReadCommand(Client& client) { return; } - std::string& incomplete_command = client.incomplete_command; - // Add the incomplete command from the last read - auto commands = std::string{incomplete_command.data()}; - commands.append(buffer.data()); - - incomplete_command.clear(); + std::string commands(std::move(client.incomplete_command)); + commands.append(buffer, bytes_read); // Replacing '\n' with '\r' absl::StrReplaceAll({{"\n", "\r"}}, &commands); @@ -132,8 +128,8 @@ void ChannelMonitor::ReadCommand(Client& client) { } pos = r_pos + 1; // Skip '\r' } else if (pos < commands.length()) { // Incomplete command - incomplete_command = commands.substr(pos); - VLOG(1) << "incomplete command: " << incomplete_command; + client.incomplete_command = commands.substr(pos); + VLOG(1) << "incomplete command: " << client.incomplete_command; } } } From 78af70721d795706be7900b9ec9fbee8905ce3cf Mon Sep 17 00:00:00 2001 From: Roman Kiryanov Date: Thu, 23 Jul 2026 19:29:54 +0000 Subject: [PATCH 08/53] modem_simulator: avoid referring to a dead object The `sms_pdu` is used in an async callback, potentially after the control leaves the scope. Bug: 509614113 Signed-off-by: Roman Kiryanov --- .../cuttlefish/host/commands/modem_simulator/sms_service.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/base/cvd/cuttlefish/host/commands/modem_simulator/sms_service.cpp b/base/cvd/cuttlefish/host/commands/modem_simulator/sms_service.cpp index 166868c66ca..5068ca18880 100644 --- a/base/cvd/cuttlefish/host/commands/modem_simulator/sms_service.cpp +++ b/base/cvd/cuttlefish/host/commands/modem_simulator/sms_service.cpp @@ -297,7 +297,7 @@ void SmsService::HandleSendSMSPDU(const Client& client, std::string& command) { thread_looper_->Post( makeSafeCallback( this, - [&sms_pdu](SmsService* me) { me->HandleReceiveSMS(sms_pdu); }), + [sms_pdu](SmsService* me) { me->HandleReceiveSMS(sms_pdu); }), std::chrono::seconds(1)); } else { // Send SMS to remote host port SendSmsToRemote(remote_host_port, sms_pdu); From e1668f47a203380c721e3472c33c5279dd1b11ed Mon Sep 17 00:00:00 2001 From: Sarah Kim Date: Mon, 20 Jul 2026 18:15:32 -0700 Subject: [PATCH 09/53] #VibeCoding Support AT+CEID and AT+CATR in modem simulator Implement custom AT commands AT+CEID and AT+CATR in the modem simulator to expose the EID and ATR values configured in the simulated SIM profile (XML). This allows the radio HAL to query these values dynamically instead of hardcoding them, supporting eSIM slot detection. BUG=532745689 --- .../etc/files/iccprofile_for_sim0.xml | 6 +- ...le_for_sim0_for_CtsCarrierApiTestCases.xml | 6 +- .../commands/modem_simulator/sim_service.cpp | 58 +++++++++++++++++++ .../commands/modem_simulator/sim_service.h | 2 + 4 files changed, 70 insertions(+), 2 deletions(-) diff --git a/base/cvd/cuttlefish/host/commands/modem_simulator/etc/files/iccprofile_for_sim0.xml b/base/cvd/cuttlefish/host/commands/modem_simulator/etc/files/iccprofile_for_sim0.xml index 655c37a967a..25ad8495b39 100755 --- a/base/cvd/cuttlefish/host/commands/modem_simulator/etc/files/iccprofile_for_sim0.xml +++ b/base/cvd/cuttlefish/host/commands/modem_simulator/etc/files/iccprofile_for_sim0.xml @@ -177,5 +177,9 @@ - + + + 3F979580BFFE8210428031A073BE211797 + 89049032000001000000000254806852 + diff --git a/base/cvd/cuttlefish/host/commands/modem_simulator/etc/files/iccprofile_for_sim0_for_CtsCarrierApiTestCases.xml b/base/cvd/cuttlefish/host/commands/modem_simulator/etc/files/iccprofile_for_sim0_for_CtsCarrierApiTestCases.xml index b4363da9308..1b65eb621a4 100755 --- a/base/cvd/cuttlefish/host/commands/modem_simulator/etc/files/iccprofile_for_sim0_for_CtsCarrierApiTestCases.xml +++ b/base/cvd/cuttlefish/host/commands/modem_simulator/etc/files/iccprofile_for_sim0_for_CtsCarrierApiTestCases.xml @@ -203,5 +203,9 @@ - + + + 3F979580BFFE8210428031A073BE211797 + 89049032000001000000000254806852 + diff --git a/base/cvd/cuttlefish/host/commands/modem_simulator/sim_service.cpp b/base/cvd/cuttlefish/host/commands/modem_simulator/sim_service.cpp index 0d5f7646fd4..46f4d802781 100644 --- a/base/cvd/cuttlefish/host/commands/modem_simulator/sim_service.cpp +++ b/base/cvd/cuttlefish/host/commands/modem_simulator/sim_service.cpp @@ -313,6 +313,12 @@ std::vector SimService::InitializeCommandHandlers() { CommandHandler( "+CICCID", [this](const Client& client) { this->HandleGetIccId(client); }), + CommandHandler( + "+CEID", + [this](const Client& client) { this->HandleGetEid(client); }), + CommandHandler( + "+CATR", + [this](const Client& client) { this->HandleGetAtr(client); }), CommandHandler("+CLCK=", [this](const Client& client, std::string& cmd) { this->HandleFacilityLock(client, cmd); @@ -1323,6 +1329,58 @@ void SimService::HandleGetIccId(const Client& client) { client.SendCommandResponse(responses); } +void SimService::HandleGetEid(const Client& client) { + std::vector responses; + + XMLElement* root = sim_file_system_.GetRootElement(); + if (!root) { + client.SendCommandResponse(kCmeErrorOperationNotAllowed); + return; + } + + XMLElement* card_profile = root->FirstChildElement("CardProfile"); + if (!card_profile) { + client.SendCommandResponse(kCmeErrorNotFound); + return; + } + + XMLElement* final = card_profile->FirstChildElement("EID"); + if (!final) { + client.SendCommandResponse(kCmeErrorNotFound); + return; + } + + responses.push_back("+CEID: " + std::string(final->GetText())); + responses.push_back("OK"); + client.SendCommandResponse(responses); +} + +void SimService::HandleGetAtr(const Client& client) { + std::vector responses; + + XMLElement* root = sim_file_system_.GetRootElement(); + if (!root) { + client.SendCommandResponse(kCmeErrorOperationNotAllowed); + return; + } + + XMLElement* card_profile = root->FirstChildElement("CardProfile"); + if (!card_profile) { + client.SendCommandResponse(kCmeErrorNotFound); + return; + } + + XMLElement* final = card_profile->FirstChildElement("ATR"); + if (!final) { + client.SendCommandResponse(kCmeErrorNotFound); + return; + } + + responses.push_back("+CATR: " + std::string(final->GetText())); + responses.push_back("OK"); + client.SendCommandResponse(responses); +} + /* * AT+CLCK * Execute command is used to lock, unlock or interrogate a MT or a network diff --git a/base/cvd/cuttlefish/host/commands/modem_simulator/sim_service.h b/base/cvd/cuttlefish/host/commands/modem_simulator/sim_service.h index 198aa697bfb..e3695f7791f 100644 --- a/base/cvd/cuttlefish/host/commands/modem_simulator/sim_service.h +++ b/base/cvd/cuttlefish/host/commands/modem_simulator/sim_service.h @@ -42,6 +42,8 @@ class SimService : public ModemService, public std::enable_shared_from_this Date: Wed, 29 Jul 2026 09:02:23 -0700 Subject: [PATCH 10/53] #VibeCoding cuttlefish: Add iccprofile_for_sim1.xml and CTS profile for dual-SIM support Add simulator profile for SIM 1 and CTS carrier API test profile to enable dual-SIM modem simulation support. These profiles are identical to their SIM 0 counterparts except for the ICCID (and its binary EF representation), IMSI, and EID. Also ignore SIGPIPE from clients in modem simulator. BUG=532745689 Test: http://go/forrest-run/L25500030157036716 --- .../etc/files/iccprofile_for_sim1.xml | 185 +++++++++++++++ ...le_for_sim1_for_CtsCarrierApiTestCases.xml | 211 ++++++++++++++++++ .../host/commands/modem_simulator/main.cpp | 4 +- base/cvd/cuttlefish/package/BUILD.bazel | 2 + e2etests/debian_substitution_marker | 10 + 5 files changed, 411 insertions(+), 1 deletion(-) create mode 100755 base/cvd/cuttlefish/host/commands/modem_simulator/etc/files/iccprofile_for_sim1.xml create mode 100755 base/cvd/cuttlefish/host/commands/modem_simulator/etc/files/iccprofile_for_sim1_for_CtsCarrierApiTestCases.xml diff --git a/base/cvd/cuttlefish/host/commands/modem_simulator/etc/files/iccprofile_for_sim1.xml b/base/cvd/cuttlefish/host/commands/modem_simulator/etc/files/iccprofile_for_sim1.xml new file mode 100755 index 00000000000..f1f77b54035 --- /dev/null +++ b/base/cvd/cuttlefish/host/commands/modem_simulator/etc/files/iccprofile_for_sim1.xml @@ -0,0 +1,185 @@ + + + + 144,0,621A8205422100300483022F008A01058B032F0601800200C08801F0 + 144,0,61184F10A0000003431002FF86FF0389FFFFFFFF50044353494DFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,61184F10A0000000871002FF86FF0389FFFFFFFF50045553494DFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + + + 144,0,62178202412183022FE28A01058B032F06038002000A880110 + 144,0,98683081462002318389 + + 89860318640220133898 + + + 144,0,62178202412183022F058A01058B032F060280020004880128 + 144,0,FFFFFFFF + + + + + + 144,0,62198205422100400283024F308A01058B036F0606800200808800 + 144,0,A81EC0034F3A01C1034F3306C5034F0902C4034F1104C6034F2503C9034F3107A905CA034F5008AA0FC2034F4A09C7034F4B0AC8034F4C0BFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + + + 144,0,621A8205422100140A83024F4C8A01058B036F060E800200C8880158 + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + + + 144,0,621A82054221001C1483024F3A8A01058B036F060E80020230880108 + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + + + 144,0,621A820542210001FA83024F338A01058B036F060E800200FA880130 + + + 144,0,621A820542210002FA83024F098A01058B036F060E800201F4880110 + + + 144,0,621A82054221000FFA83024F118A01058B036F060E80020EA6880120 + + + + + + + + 311740123456790 + + + 144,0,621982054221001C0283026F408A01058B036F0605800200388800 + 144,0,000000000000000000000000000007915155214365F7FFFFFFFFFFFF + + + 144,0,62198205422100050183026FC98A01058B036F0602800200058800 + 144,0,0100000000 + + + 144,0,621982054221001C0283026F408A01058B036F06058002003E8800 + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF07915155674523F1FFFFFFFFFFFF + + + 144,0,62178202412183026FAD8A01058B036F060180020004880118 + 144,0,00000003 + + + 144,0,62198205422100050183026FCA8A01058B036F060E800200058800 + 144,0,0000000000 + + + 106,130 + + + 144,0,621C8202412183026F7BA5038001718A01058B036F06038002001E880168 + 144,0,64F00064F02064F04064F07064F080FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + + + 144,0,621982054221001C0A83026F3B8A01058B036F0605800201188800 + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + + + + + + + 4,6124 + 76,62228202412183025031A503C001408A01058B066F0601010001800200108102002288009000 + 36,A706300404024401A5063004040244029000 + + + + 6,019000 + 4,6b00 + + + + + + + + PINSTATE_UNKNOWN + 1234 + 12345678 + 3 + 10 + 1234 + 12345678 + 3 + 10 + + + + DISABLE + DISABLE + DISABLE + DISABLE + DISABLE + DISABLE + DISABLE + DISABLE + DISABLE + + + + + + + + + + + + + + + + + + + + + 3F979580BFFE8210428031A073BE211797 + 89049032000001000000000254806853 + + diff --git a/base/cvd/cuttlefish/host/commands/modem_simulator/etc/files/iccprofile_for_sim1_for_CtsCarrierApiTestCases.xml b/base/cvd/cuttlefish/host/commands/modem_simulator/etc/files/iccprofile_for_sim1_for_CtsCarrierApiTestCases.xml new file mode 100755 index 00000000000..c3e6db772bc --- /dev/null +++ b/base/cvd/cuttlefish/host/commands/modem_simulator/etc/files/iccprofile_for_sim1_for_CtsCarrierApiTestCases.xml @@ -0,0 +1,211 @@ + + + + 144,0,621A8205422100300483022F008A01058B032F0601800200C08801F0 + 144,0,61184F10A0000003431002FF86FF0389FFFFFFFF50044353494DFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,61184F10A0000000871002FF86FF0389FFFFFFFF50045553494DFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + + + 144,0,62178202412183022FE28A01058B032F06038002000A880110 + 144,0,98683081462002318389 + + 89860318640220133898 + + + 144,0,62178202412183022F058A01058B032F060280020004880128 + 144,0,FFFFFFFF + + + + + + 144,0,62198205422100400283024F308A01058B036F0606800200808800 + 144,0,A81EC0034F3A01C1034F3306C5034F0902C4034F1104C6034F2503C9034F3107A905CA034F5008AA0FC2034F4A09C7034F4B0AC8034F4C0BFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + + + 144,0,621A8205422100140A83024F4C8A01058B036F060E800200C8880158 + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + + + 144,0,621A82054221001C1483024F3A8A01058B036F060E80020230880108 + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + + + 144,0,621A820542210001FA83024F338A01058B036F060E800200FA880130 + + + 144,0,621A820542210002FA83024F098A01058B036F060E800201F4880110 + + + 144,0,621A82054221000FFA83024F118A01058B036F060E80020EA6880120 + + + + + + + + 311740123456790 + + + 144,0,621982054221001C0283026F408A01058B036F0605800200388800 + 144,0,00000000000000000000000000000891688118109844F0FFFFFFFFFF + + + 144,0,62258205422100040183026FC9A503C001408A01058B066F060103000080020004810200188800 + 144,0,01000000 + + + 144,0,62178202412183026FAD8A01058B036F060180020004880118 + 144,0,00000002 + + + 144,0,62258205422100260483026FC7A503C001408A01058B066F060103000080020098810200AC8800 + 144,0 + 144,0 + 144,0 + + + 144,0,62198205422100050183026FCA8A01058B036F060E800200058800 + 144,0,0000000000 + + + 106,130 + + + 144,0,621C8202412183026F7BA5038001718A01058B036F06038002001E880168 + 144,0,64F00064F02064F04064F07064F080FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + + + 144,0,621982054221001C0A83026F3B8A01058B036F0605800201188800 + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 144,0,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + + + + + + + + 76,62228202412183024300A503C001408A01058B066F0601010001800201DC810201EE88009000 + 516,30088200300404024310301AA0120410A000000476416E64726F696443545340300404024311301AA0120410A000000476416E64726F696443545341300404024312301AA0120410A000000476416E64726F696443545342300404024313301AA0120410A000000476416E64726F696443545343300404024314301AA0120410A000000476416E64726F696443545344300404024315301AA0120410A000000476416E64726F696443545345300404024316301AA0120410A000000476416E64726F6964435453463004040243173010A0080406FFFFFFFFFFFF300404024318301AA0120410A000000476416E64726F696443545347300404024313301AA0129000 + + + 76,62228202412183024318A503C001408A01058B066F0601010001800200188102002A88009000 + 124,3016041461ED377E85D386A8DFEE6B864BD85B0BFAA5AF8130220420CE7B2B47AE2B7552C8F92CC29124279883041FB623A5F194A82C9BF15D492AA09000 + + + + + 6,019000 + 110,62338202782183023F00A50C80016187010183040007DBF08A01058B062F0601020002C60C90016083010183010A83010D8102FFFF9000 + 6,019000 + 4,9000 + 4,6C35 + 4,6B00 + 4,9000 + 4,6D00 + 4,6B00 + 4,6A82 + 4,6A81 + 4,6E00 + 4,9000 + 24,983311111111111111029000 + 78,622382054221004A1283022F06A503C001408A01058B062F060101000080020534810205489000 + + + + + 6,019000 + 4,6b00 + + + + + + + + PINSTATE_UNKNOWN + 1234 + 12345678 + 3 + 10 + 1234 + 12345678 + 3 + 10 + + + + DISABLE + DISABLE + DISABLE + DISABLE + DISABLE + DISABLE + DISABLE + DISABLE + DISABLE + + + + + + + + + + + + + + + + + + + + + 3F979580BFFE8210428031A073BE211797 + 89049032000001000000000254806853 + + diff --git a/base/cvd/cuttlefish/host/commands/modem_simulator/main.cpp b/base/cvd/cuttlefish/host/commands/modem_simulator/main.cpp index 3bfc1ec2e99..040b5cce472 100644 --- a/base/cvd/cuttlefish/host/commands/modem_simulator/main.cpp +++ b/base/cvd/cuttlefish/host/commands/modem_simulator/main.cpp @@ -89,7 +89,9 @@ int ModemSimulatorMain(int argc, char** argv) { NvramConfig::InitNvramConfigService(server_fds.size(), FLAGS_sim_type); // Don't get a SIGPIPE from the clients - if (sigaction(SIGPIPE, nullptr, nullptr) != 0) { + struct sigaction sa{}; + sa.sa_handler = SIG_IGN; + if (sigaction(SIGPIPE, &sa, nullptr) != 0) { LOG(ERROR) << "Failed to set SIGPIPE to be ignored: " << strerror(errno); } diff --git a/base/cvd/cuttlefish/package/BUILD.bazel b/base/cvd/cuttlefish/package/BUILD.bazel index cbc54adb2b1..6fd93fe0b0e 100644 --- a/base/cvd/cuttlefish/package/BUILD.bazel +++ b/base/cvd/cuttlefish/package/BUILD.bazel @@ -117,6 +117,8 @@ package_files( "cuttlefish-common/etc/cvd_custom_action_config/cuttlefish_example_action_config.json": "//cuttlefish/host/example_custom_actions:custom_action_config.json", "cuttlefish-common/etc/modem_simulator/files/iccprofile_for_sim0_for_CtsCarrierApiTestCases.xml": "//cuttlefish/host/commands/modem_simulator:etc/files/iccprofile_for_sim0_for_CtsCarrierApiTestCases.xml", "cuttlefish-common/etc/modem_simulator/files/iccprofile_for_sim0.xml": "//cuttlefish/host/commands/modem_simulator:etc/files/iccprofile_for_sim0.xml", + "cuttlefish-common/etc/modem_simulator/files/iccprofile_for_sim1_for_CtsCarrierApiTestCases.xml": "//cuttlefish/host/commands/modem_simulator:etc/files/iccprofile_for_sim1_for_CtsCarrierApiTestCases.xml", + "cuttlefish-common/etc/modem_simulator/files/iccprofile_for_sim1.xml": "//cuttlefish/host/commands/modem_simulator:etc/files/iccprofile_for_sim1.xml", "cuttlefish-common/etc/modem_simulator/files/numeric_operator.xml": "//cuttlefish/host/commands/modem_simulator:etc/files/numeric_operator.xml", # "cuttlefish-common/bin/crosvm": "@crosvm_bin//:crosvm__crosvm", # TODO: b/402274999 - currently requires --enable_sandbox=false "cuttlefish-common/usr/share/webrtc/assets/client.html": "//cuttlefish/host/frontend/webrtc/html_client:client.html", diff --git a/e2etests/debian_substitution_marker b/e2etests/debian_substitution_marker index 83c485fcbfb..67931cfb2e4 100644 --- a/e2etests/debian_substitution_marker +++ b/e2etests/debian_substitution_marker @@ -275,6 +275,16 @@ symlinks: { link_name: "etc/modem_simulator/files/iccprofile_for_sim0.xml" } +symlinks: { + target: "/usr/lib/cuttlefish-common/etc/modem_simulator/files/iccprofile_for_sim1_for_CtsCarrierApiTestCases.xml" + link_name: "etc/modem_simulator/files/iccprofile_for_sim1_for_CtsCarrierApiTestCases.xml" +} + +symlinks: { + target: "/usr/lib/cuttlefish-common/etc/modem_simulator/files/iccprofile_for_sim1.xml" + link_name: "etc/modem_simulator/files/iccprofile_for_sim1.xml" +} + symlinks: { target: "/usr/lib/cuttlefish-common/etc/modem_simulator/files/numeric_operator.xml" link_name: "etc/modem_simulator/files/numeric_operator.xml" From 1c3766361645329b2ba769630df03b23b88793e4 Mon Sep 17 00:00:00 2001 From: "A. Cody Schuffelen" Date: Thu, 16 Jul 2026 14:19:22 -0700 Subject: [PATCH 11/53] Fix dependency issues with fetch:build_api_credentials Bug: b/534499070 --- base/cvd/cuttlefish/host/commands/cvd/fetch/BUILD.bazel | 2 +- .../cuttlefish/host/commands/cvd/fetch/build_api_credentials.cc | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/base/cvd/cuttlefish/host/commands/cvd/fetch/BUILD.bazel b/base/cvd/cuttlefish/host/commands/cvd/fetch/BUILD.bazel index 5db93be1685..8f86437bd52 100644 --- a/base/cvd/cuttlefish/host/commands/cvd/fetch/BUILD.bazel +++ b/base/cvd/cuttlefish/host/commands/cvd/fetch/BUILD.bazel @@ -40,11 +40,11 @@ cf_cc_library( "//cuttlefish/common/libs/utils:files", "//cuttlefish/common/libs/utils:json", "//cuttlefish/host/commands/cvd/fetch:build_api_flags", - "//cuttlefish/host/commands/cvd/fetch:credential_flags", "//cuttlefish/host/libs/web:credential_source", "//cuttlefish/host/libs/web/http_client", "//cuttlefish/result", "@abseil-cpp//absl/log", + "@jsoncpp", ], ) diff --git a/base/cvd/cuttlefish/host/commands/cvd/fetch/build_api_credentials.cc b/base/cvd/cuttlefish/host/commands/cvd/fetch/build_api_credentials.cc index 48a174b2f54..053258b871a 100644 --- a/base/cvd/cuttlefish/host/commands/cvd/fetch/build_api_credentials.cc +++ b/base/cvd/cuttlefish/host/commands/cvd/fetch/build_api_credentials.cc @@ -20,6 +20,8 @@ #include #include "absl/log/log.h" +#include "json/reader.h" +#include "json/value.h" #include "cuttlefish/common/libs/utils/environment.h" #include "cuttlefish/common/libs/utils/files.h" From 7d7b96f283452f928b1743f0f6b9805023a9fdfc Mon Sep 17 00:00:00 2001 From: "A. Cody Schuffelen" Date: Thu, 16 Jul 2026 14:21:54 -0700 Subject: [PATCH 12/53] Fix dependency issues with fetch:build_api_flags Bug: b/534499070 --- base/cvd/cuttlefish/host/commands/cvd/fetch/BUILD.bazel | 1 - base/cvd/cuttlefish/host/commands/cvd/fetch/build_api_flags.cc | 1 - 2 files changed, 2 deletions(-) diff --git a/base/cvd/cuttlefish/host/commands/cvd/fetch/BUILD.bazel b/base/cvd/cuttlefish/host/commands/cvd/fetch/BUILD.bazel index 8f86437bd52..df24af71fb7 100644 --- a/base/cvd/cuttlefish/host/commands/cvd/fetch/BUILD.bazel +++ b/base/cvd/cuttlefish/host/commands/cvd/fetch/BUILD.bazel @@ -59,7 +59,6 @@ cf_cc_library( "//cuttlefish/host/libs/web:android_build_url", "//cuttlefish/host/libs/web/cas:cas_flags", "//cuttlefish/result", - "//libbase", "@abseil-cpp//absl/strings", ], ) diff --git a/base/cvd/cuttlefish/host/commands/cvd/fetch/build_api_flags.cc b/base/cvd/cuttlefish/host/commands/cvd/fetch/build_api_flags.cc index 07efbaadc3d..990a823ef6f 100644 --- a/base/cvd/cuttlefish/host/commands/cvd/fetch/build_api_flags.cc +++ b/base/cvd/cuttlefish/host/commands/cvd/fetch/build_api_flags.cc @@ -16,7 +16,6 @@ #include "cuttlefish/host/commands/cvd/fetch/build_api_flags.h" #include -#include #include #include From 5b8c6c9121b706943a38dbc0754c6ba4b1eb4660 Mon Sep 17 00:00:00 2001 From: "A. Cody Schuffelen" Date: Thu, 16 Jul 2026 14:25:03 -0700 Subject: [PATCH 13/53] Fix dependency issues with fetch:downloaders Bug: b/534499070 --- base/cvd/cuttlefish/host/commands/cvd/fetch/BUILD.bazel | 2 -- base/cvd/cuttlefish/host/commands/cvd/fetch/downloaders.cc | 1 - base/cvd/cuttlefish/host/commands/cvd/fetch/downloaders.h | 2 +- 3 files changed, 1 insertion(+), 4 deletions(-) diff --git a/base/cvd/cuttlefish/host/commands/cvd/fetch/BUILD.bazel b/base/cvd/cuttlefish/host/commands/cvd/fetch/BUILD.bazel index df24af71fb7..7a02064fb1c 100644 --- a/base/cvd/cuttlefish/host/commands/cvd/fetch/BUILD.bazel +++ b/base/cvd/cuttlefish/host/commands/cvd/fetch/BUILD.bazel @@ -126,9 +126,7 @@ cf_cc_library( "//cuttlefish/common/libs/utils:environment", "//cuttlefish/host/commands/cvd/fetch:build_api_credentials", "//cuttlefish/host/commands/cvd/fetch:build_api_flags", - "//cuttlefish/host/commands/cvd/fetch:fetch_cvd_parser", "//cuttlefish/host/libs/web:android_build_api", - "//cuttlefish/host/libs/web:android_build_api_key", "//cuttlefish/host/libs/web:android_build_url", "//cuttlefish/host/libs/web:build_api", "//cuttlefish/host/libs/web:caching_build_api", diff --git a/base/cvd/cuttlefish/host/commands/cvd/fetch/downloaders.cc b/base/cvd/cuttlefish/host/commands/cvd/fetch/downloaders.cc index 2c421186284..be7bd1d77c7 100644 --- a/base/cvd/cuttlefish/host/commands/cvd/fetch/downloaders.cc +++ b/base/cvd/cuttlefish/host/commands/cvd/fetch/downloaders.cc @@ -23,7 +23,6 @@ #include "cuttlefish/common/libs/utils/environment.h" #include "cuttlefish/host/commands/cvd/fetch/build_api_credentials.h" #include "cuttlefish/host/commands/cvd/fetch/build_api_flags.h" -#include "cuttlefish/host/commands/cvd/fetch/fetch_cvd_parser.h" #include "cuttlefish/host/libs/web/android_build_api.h" #include "cuttlefish/host/libs/web/android_build_url.h" #include "cuttlefish/host/libs/web/build_api.h" diff --git a/base/cvd/cuttlefish/host/commands/cvd/fetch/downloaders.h b/base/cvd/cuttlefish/host/commands/cvd/fetch/downloaders.h index 83df7bfad2c..2d34c98d68f 100644 --- a/base/cvd/cuttlefish/host/commands/cvd/fetch/downloaders.h +++ b/base/cvd/cuttlefish/host/commands/cvd/fetch/downloaders.h @@ -18,7 +18,7 @@ #include #include -#include "cuttlefish/host/commands/cvd/fetch/fetch_cvd_parser.h" +#include "cuttlefish/host/commands/cvd/fetch/build_api_flags.h" #include "cuttlefish/host/libs/web/build_api.h" #include "cuttlefish/host/libs/web/luci_build_api.h" #include "cuttlefish/result/result.h" From 402e0df33230b2b9683d79e89d5314df58aa7ae5 Mon Sep 17 00:00:00 2001 From: "A. Cody Schuffelen" Date: Thu, 16 Jul 2026 14:26:58 -0700 Subject: [PATCH 14/53] Fix build issues with fetch:fetch_context Bug: b/534499070 --- base/cvd/cuttlefish/host/commands/cvd/fetch/BUILD.bazel | 2 -- 1 file changed, 2 deletions(-) diff --git a/base/cvd/cuttlefish/host/commands/cvd/fetch/BUILD.bazel b/base/cvd/cuttlefish/host/commands/cvd/fetch/BUILD.bazel index 7a02064fb1c..6525e4242c4 100644 --- a/base/cvd/cuttlefish/host/commands/cvd/fetch/BUILD.bazel +++ b/base/cvd/cuttlefish/host/commands/cvd/fetch/BUILD.bazel @@ -170,7 +170,6 @@ cf_cc_library( srcs = ["fetch_context.cc"], hdrs = ["fetch_context.h"], deps = [ - "//cuttlefish/common/libs/utils:archive", "//cuttlefish/common/libs/utils:files", "//cuttlefish/host/commands/cvd/fetch:builds", "//cuttlefish/host/commands/cvd/fetch:de_android_sparse", @@ -184,7 +183,6 @@ cf_cc_library( "//cuttlefish/host/libs/web:build_api_zip", "//cuttlefish/host/libs/zip:zip_file", "//cuttlefish/host/libs/zip/libzip_cc:archive", - "//cuttlefish/posix:strerror", "//cuttlefish/result", "//libbase", "@abseil-cpp//absl/strings", From e98d2235ffe148ace64cb0f4ee356c563d4a4440 Mon Sep 17 00:00:00 2001 From: "A. Cody Schuffelen" Date: Thu, 16 Jul 2026 14:28:44 -0700 Subject: [PATCH 15/53] Fix dependency issues with fetch:fetch_cvd Bug: b/534499070 --- base/cvd/cuttlefish/host/commands/cvd/fetch/BUILD.bazel | 2 -- 1 file changed, 2 deletions(-) diff --git a/base/cvd/cuttlefish/host/commands/cvd/fetch/BUILD.bazel b/base/cvd/cuttlefish/host/commands/cvd/fetch/BUILD.bazel index 6525e4242c4..97e7db26f57 100644 --- a/base/cvd/cuttlefish/host/commands/cvd/fetch/BUILD.bazel +++ b/base/cvd/cuttlefish/host/commands/cvd/fetch/BUILD.bazel @@ -209,7 +209,6 @@ cf_cc_library( "//cuttlefish/host/commands/cvd/fetch:fetch_tracer", "//cuttlefish/host/commands/cvd/fetch:host_package", "//cuttlefish/host/commands/cvd/fetch:host_tools_target", - "//cuttlefish/host/commands/cvd/fetch:substitute", "//cuttlefish/host/commands/cvd/fetch:target_directories", "//cuttlefish/host/commands/cvd/utils:common", "//cuttlefish/host/libs/config:fetcher_config", @@ -221,7 +220,6 @@ cf_cc_library( "//cuttlefish/host/libs/web:chrome_os_build_string", "//cuttlefish/host/libs/web:luci_build_api", "//cuttlefish/host/libs/web/http_client:curl_global_init", - "//cuttlefish/host/libs/zip:zip_string", "//cuttlefish/host/libs/zip/libzip_cc:archive", "//cuttlefish/io", "//cuttlefish/io:string", From 949efe456a5343aea5eb6af17d3b7ce6266361f6 Mon Sep 17 00:00:00 2001 From: "A. Cody Schuffelen" Date: Tue, 4 Aug 2026 13:49:06 -0700 Subject: [PATCH 16/53] Extract parse_time to a separate function Bug: b/542342091 --- base/cvd/cuttlefish/host/libs/web/BUILD.bazel | 11 +++++ .../host/libs/web/android_build_api.cpp | 13 +----- .../cuttlefish/host/libs/web/parse_time.cc | 40 +++++++++++++++++++ .../cvd/cuttlefish/host/libs/web/parse_time.h | 28 +++++++++++++ 4 files changed, 80 insertions(+), 12 deletions(-) create mode 100644 base/cvd/cuttlefish/host/libs/web/parse_time.cc create mode 100644 base/cvd/cuttlefish/host/libs/web/parse_time.h diff --git a/base/cvd/cuttlefish/host/libs/web/BUILD.bazel b/base/cvd/cuttlefish/host/libs/web/BUILD.bazel index 77782ea71cc..ddf119f13a5 100644 --- a/base/cvd/cuttlefish/host/libs/web/BUILD.bazel +++ b/base/cvd/cuttlefish/host/libs/web/BUILD.bazel @@ -32,6 +32,7 @@ cf_cc_library( "//cuttlefish/host/libs/web:android_build_url", "//cuttlefish/host/libs/web:build_api", "//cuttlefish/host/libs/web:credential_source", + "//cuttlefish/host/libs/web:parse_time", "//cuttlefish/host/libs/web/cas:cas_downloader", "//cuttlefish/host/libs/web/http_client", "//cuttlefish/host/libs/web/http_client:http_file", @@ -248,3 +249,13 @@ cf_cc_library( "@zlib", ], ) + +cf_cc_library( + name = "parse_time", + srcs = ["parse_time.cc"], + hdrs = ["parse_time.h"], + deps = [ + "//cuttlefish/result:expect", + "//cuttlefish/result:result_type", + ], +) diff --git a/base/cvd/cuttlefish/host/libs/web/android_build_api.cpp b/base/cvd/cuttlefish/host/libs/web/android_build_api.cpp index 878b3470388..8ca9c004b99 100644 --- a/base/cvd/cuttlefish/host/libs/web/android_build_api.cpp +++ b/base/cvd/cuttlefish/host/libs/web/android_build_api.cpp @@ -16,17 +16,14 @@ #include "cuttlefish/host/libs/web/android_build_api.h" #include -#include #include #include #include -#include #include #include #include #include -#include #include #include #include @@ -53,6 +50,7 @@ #include "cuttlefish/host/libs/web/http_client/http_client.h" #include "cuttlefish/host/libs/web/http_client/http_file.h" #include "cuttlefish/host/libs/web/http_client/http_json.h" +#include "cuttlefish/host/libs/web/parse_time.h" #include "cuttlefish/host/libs/zip/libzip_cc/seekable_source.h" #include "cuttlefish/host/libs/zip/libzip_cc/writable_source.h" #include "cuttlefish/host/libs/zip/remote_zip.h" @@ -90,15 +88,6 @@ Result GetResponseJson(const HttpResponse& response, return response.data; } -Result ParseTime(std::string_view str) { - std::stringstream stream = std::stringstream(std::string(str)); - tm time_tm; - stream >> std::get_time(&time_tm, "%Y-%m-%dT%H:%M:%S."); - CF_EXPECTF(!!stream, "Failed to parse time '{}'", str); - - return std::chrono::system_clock::from_time_t(mktime(&time_tm)); -} - } // namespace AndroidBuildApi::AndroidBuildApi(HttpClient& http_client, diff --git a/base/cvd/cuttlefish/host/libs/web/parse_time.cc b/base/cvd/cuttlefish/host/libs/web/parse_time.cc new file mode 100644 index 00000000000..5871a91893e --- /dev/null +++ b/base/cvd/cuttlefish/host/libs/web/parse_time.cc @@ -0,0 +1,40 @@ +// +// Copyright (C) 2019 The Android Open Source Project +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "cuttlefish/host/libs/web/parse_time.h" + +#include + +#include +#include +#include +#include +#include + +#include "cuttlefish/result/expect.h" +#include "cuttlefish/result/result_type.h" + +namespace cuttlefish { + +Result ParseTime(std::string_view str) { + std::stringstream stream = std::stringstream(std::string(str)); + tm time_tm; + stream >> std::get_time(&time_tm, "%Y-%m-%dT%H:%M:%S."); + CF_EXPECTF(!!stream, "Failed to parse time '{}'", str); + + return std::chrono::system_clock::from_time_t(mktime(&time_tm)); +} + +} // namespace cuttlefish diff --git a/base/cvd/cuttlefish/host/libs/web/parse_time.h b/base/cvd/cuttlefish/host/libs/web/parse_time.h new file mode 100644 index 00000000000..4c9c13bac14 --- /dev/null +++ b/base/cvd/cuttlefish/host/libs/web/parse_time.h @@ -0,0 +1,28 @@ +// +// Copyright (C) 2019 The Android Open Source Project +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#pragma once + +#include +#include +#include + +#include "cuttlefish/result/result_type.h" + +namespace cuttlefish { + +Result ParseTime(std::string_view str); + +} // namespace cuttlefish From a6f585fb0259274d552ecf5c0b003f4b96a216ee Mon Sep 17 00:00:00 2001 From: "A. Cody Schuffelen" Date: Tue, 4 Aug 2026 13:55:20 -0700 Subject: [PATCH 17/53] Add a test for ParseTime Bug: b/542342091 --- base/cvd/cuttlefish/host/libs/web/BUILD.bazel | 9 ++++++ .../host/libs/web/parse_time_test.cc | 31 +++++++++++++++++++ 2 files changed, 40 insertions(+) create mode 100644 base/cvd/cuttlefish/host/libs/web/parse_time_test.cc diff --git a/base/cvd/cuttlefish/host/libs/web/BUILD.bazel b/base/cvd/cuttlefish/host/libs/web/BUILD.bazel index ddf119f13a5..2c6584d5ffc 100644 --- a/base/cvd/cuttlefish/host/libs/web/BUILD.bazel +++ b/base/cvd/cuttlefish/host/libs/web/BUILD.bazel @@ -259,3 +259,12 @@ cf_cc_library( "//cuttlefish/result:result_type", ], ) + +cf_cc_test( + name = "parse_time_test", + srcs = ["parse_time_test.cc"], + deps = [ + "//cuttlefish/host/libs/web:parse_time", + "//cuttlefish/result:result_matchers", + ], +) diff --git a/base/cvd/cuttlefish/host/libs/web/parse_time_test.cc b/base/cvd/cuttlefish/host/libs/web/parse_time_test.cc new file mode 100644 index 00000000000..400f179caf4 --- /dev/null +++ b/base/cvd/cuttlefish/host/libs/web/parse_time_test.cc @@ -0,0 +1,31 @@ +// +// Copyright (C) 2026 The Android Open Source Project +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "cuttlefish/host/libs/web/parse_time.h" + +#include "gmock/gmock.h" +#include "gtest/gtest.h" + +#include "cuttlefish/result/result_matchers.h" + +namespace cuttlefish { +namespace { + +TEST(ParseTimeTest, WithMilliseconds) { + EXPECT_THAT(ParseTime("2026-08-03T11:56:20.100Z"), IsOk()); +} + +} // namespace +} // namespace cuttlefish From 962ad515ded49a7ea1cea2a5e2c14c90d20e9285 Mon Sep 17 00:00:00 2001 From: "A. Cody Schuffelen" Date: Tue, 4 Aug 2026 13:56:10 -0700 Subject: [PATCH 18/53] Fix parsing timestamps without milliseconds Bug: b/542342091 --- base/cvd/cuttlefish/host/libs/web/parse_time.cc | 2 +- base/cvd/cuttlefish/host/libs/web/parse_time_test.cc | 4 ++++ 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/base/cvd/cuttlefish/host/libs/web/parse_time.cc b/base/cvd/cuttlefish/host/libs/web/parse_time.cc index 5871a91893e..d53a0322012 100644 --- a/base/cvd/cuttlefish/host/libs/web/parse_time.cc +++ b/base/cvd/cuttlefish/host/libs/web/parse_time.cc @@ -31,7 +31,7 @@ namespace cuttlefish { Result ParseTime(std::string_view str) { std::stringstream stream = std::stringstream(std::string(str)); tm time_tm; - stream >> std::get_time(&time_tm, "%Y-%m-%dT%H:%M:%S."); + stream >> std::get_time(&time_tm, "%Y-%m-%dT%H:%M:%S"); CF_EXPECTF(!!stream, "Failed to parse time '{}'", str); return std::chrono::system_clock::from_time_t(mktime(&time_tm)); diff --git a/base/cvd/cuttlefish/host/libs/web/parse_time_test.cc b/base/cvd/cuttlefish/host/libs/web/parse_time_test.cc index 400f179caf4..44c54f4de32 100644 --- a/base/cvd/cuttlefish/host/libs/web/parse_time_test.cc +++ b/base/cvd/cuttlefish/host/libs/web/parse_time_test.cc @@ -27,5 +27,9 @@ TEST(ParseTimeTest, WithMilliseconds) { EXPECT_THAT(ParseTime("2026-08-03T11:56:20.100Z"), IsOk()); } +TEST(ParseTimeTest, WithoutMilliseconds) { + EXPECT_THAT(ParseTime("2026-08-03T11:56:20Z"), IsOk()); +} + } // namespace } // namespace cuttlefish From 1e048e5da884aceb3f1e869fb24f6be544ce7e4d Mon Sep 17 00:00:00 2001 From: Dmitrii Merkurev Date: Tue, 28 Jul 2026 11:55:47 +0100 Subject: [PATCH 19/53] gigabyte-ampere-cuttlefish-installer: pin kernel and NVIDIA driver Install kernel 6.18.15-1~bpo13+1 (validated for ARM64 nested virtualization on AmpereOne) and the matching NVIDIA driver 550.163.01-4~bpo13+1 from a snapshot.debian.org archive snapshot Bug: 537008147 Signed-off-by: Dmitrii Merkurev --- .../action.yaml | 11 ++++++-- .../addpreseed.sh | 7 ++++- .../preseed/after_install_1.sh | 27 +++++++++++-------- .../preseed/debian-snapshot.list | 1 + .../preseed/preseed.cfg | 6 +++-- 5 files changed, 36 insertions(+), 16 deletions(-) create mode 100644 gigabyte-ampere-cuttlefish-installer/preseed/debian-snapshot.list diff --git a/.github/actions/gigabyte-ampere-cuttlefish-installer-check-preseed-after-install-script/action.yaml b/.github/actions/gigabyte-ampere-cuttlefish-installer-check-preseed-after-install-script/action.yaml index 502cd5b9975..f31c36df9a1 100644 --- a/.github/actions/gigabyte-ampere-cuttlefish-installer-check-preseed-after-install-script/action.yaml +++ b/.github/actions/gigabyte-ampere-cuttlefish-installer-check-preseed-after-install-script/action.yaml @@ -17,16 +17,17 @@ runs: apt-get update apt-get upgrade -y apt-get install -y sudo + apt-get install -y ca-certificates apt-get install -y initramfs-tools apt-get install -y grub-efi-arm64 apt-get install -y lsb-release apt-get install -y pciutils apt-get install -y apt-show-versions apt-get install -y linux-image-arm64 linux-headers-arm64 - - name: Setup non-free repository + - name: Setup base and non-free repository shell: bash run: | - echo "deb http://deb.debian.org/debian $(lsb_release -c -s) contrib non-free non-free-firmware" | tee /etc/apt/sources.list.d/debian-nonfree-1.list + echo "deb http://deb.debian.org/debian $(lsb_release -c -s) main contrib non-free non-free-firmware" | tee /etc/apt/sources.list apt -o Apt::Get::Assume-Yes=true -o APT::Color=0 -o DPkgPM::Progress-Fancy=0 update - name: Setup backports repository shell: bash @@ -35,6 +36,12 @@ runs: echo "deb http://deb.debian.org/debian $(lsb_release -c -s)-backports main contrib non-free non-free-firmware" | tee /etc/apt/sources.list.d/debian-backports-1.list apt -o Apt::Get::Assume-Yes=true -o APT::Color=0 -o DPkgPM::Progress-Fancy=0 update fi + - name: Setup pinned snapshot source + working-directory: ./gigabyte-ampere-cuttlefish-installer + shell: bash + run: | + mkdir -p /root/debian-snapshot + cp -f preseed/debian-snapshot.list /root/debian-snapshot/ - name: Check nVidia GPU emulation shell: bash run: echo "EMULATE_NVIDIA_GPU=${{ inputs.emulate-nvidia }}" >> $GITHUB_ENV diff --git a/gigabyte-ampere-cuttlefish-installer/addpreseed.sh b/gigabyte-ampere-cuttlefish-installer/addpreseed.sh index c0bc88a2cb1..b46c0d67ccb 100755 --- a/gigabyte-ampere-cuttlefish-installer/addpreseed.sh +++ b/gigabyte-ampere-cuttlefish-installer/addpreseed.sh @@ -11,6 +11,7 @@ new_iso=preseed-mini.iso PRESEEDFILE=$(realpath "${BASEDIR}"/preseed/preseed.cfg) AFTERINSTALLSCRIPT=$(realpath "${BASEDIR}"/preseed/after_install_1.sh) +DEBIANSNAPSHOTLIST=$(realpath "${BASEDIR}"/preseed/debian-snapshot.list) part_img_ready=1 if test "$auto_extract_efi" = 1; then @@ -34,6 +35,7 @@ bsdtar -C ${new_files} -xf "$orig_iso" cd ${new_files} cp -f "${PRESEEDFILE}" preseed.cfg cp -f "${AFTERINSTALLSCRIPT}" after_install_1.sh +cp -f "${DEBIANSNAPSHOTLIST}" debian-snapshot.list chmod a+rx after_install_1.sh # add preseed to console based installer @@ -41,6 +43,7 @@ chmod ug+w initrd.gz gzip -d -f initrd.gz echo preseed.cfg | cpio -H newc -o -A -F initrd echo after_install_1.sh | cpio -H newc -o -A -F initrd +echo debian-snapshot.list | cpio -H newc -o -A -F initrd gzip -9 initrd chmod a-w initrd.gz # add preseed to GTK based installer @@ -50,11 +53,13 @@ chmod ug+w initrd.gz gzip -d -f initrd.gz cp -f ../preseed.cfg . cp -f ../after_install_1.sh . +cp -f ../debian-snapshot.list . echo preseed.cfg | cpio -H newc -o -A -F initrd echo after_install_1.sh | cpio -H newc -o -A -F initrd +echo debian-snapshot.list | cpio -H newc -o -A -F initrd gzip -9 initrd chmod a-w initrd.gz -rm -f preseed.cfg after_install_1.sh +rm -f preseed.cfg after_install_1.sh debian-snapshot.list cd .. chmod a-w gtk # modify Graphical installer to use tty1 diff --git a/gigabyte-ampere-cuttlefish-installer/preseed/after_install_1.sh b/gigabyte-ampere-cuttlefish-installer/preseed/after_install_1.sh index f16d67d61e2..a3cddc67bcc 100755 --- a/gigabyte-ampere-cuttlefish-installer/preseed/after_install_1.sh +++ b/gigabyte-ampere-cuttlefish-installer/preseed/after_install_1.sh @@ -20,23 +20,23 @@ adduser vsoc-01 kvm adduser vsoc-01 render adduser vsoc-01 video -# Detect distribution -DEBIAN_DISTRIBUTION="$(lsb_release -c -s)" -DEBIAN_ARCH="$(dpkg --print-architecture)" - -apt -o Apt::Get::Assume-Yes=true -o APT::Color=0 -o DPkgPM::Progress-Fancy=0 \ - update +apt -o Apt::Get::Assume-Yes=true -o APT::Color=0 -o DPkgPM::Progress-Fancy=0 update # Install kernel DEBIAN_DISTRIBUTION="$(lsb_release -c -s)" +DEBIAN_SNAPSHOT_DIR="/root/debian-snapshot" #apt-get install -y '^linux-image-6.1.*aosp14-linaro.*' '^linux-headers-6.1.*aosp14-linaro.*' has_backports=$(apt-cache policy | grep "${DEBIAN_DISTRIBUTION}-backports") if [ x"$has_backports" != x"" ]; then apt install -y -t "${DEBIAN_DISTRIBUTION}-backports" linux-headers-arm64 apt install -y -t "${DEBIAN_DISTRIBUTION}-backports" linux-image-arm64 else - apt install -y linux-headers-arm64 - apt install -y linux-image-arm64 + KERNEL_ABI="6.18.15+deb13-arm64" + KERNEL_DEB_VERSION="6.18.15-1~bpo13+1" + apt-get -o Dir::Etc::SourceParts="${DEBIAN_SNAPSHOT_DIR}" -o Acquire::Retries=5 update + apt-get install -y -o Dir::Etc::SourceParts="${DEBIAN_SNAPSHOT_DIR}" -o Acquire::Retries=5 \ + "linux-image-${KERNEL_ABI}=${KERNEL_DEB_VERSION}" \ + "linux-headers-${KERNEL_ABI}=${KERNEL_DEB_VERSION}" || exit 1 fi # Install nVidia or AMD GPU driver @@ -59,9 +59,14 @@ elif [ x"$nvidia_gpu" != x"" ]; then DEBIAN_FRONTEND=noninteractive apt-get install -y -t "${DEBIAN_DISTRIBUTION}-backports" -q --force-yes nvidia-driver DEBIAN_FRONTEND=noninteractive apt-get install -y -t "${DEBIAN_DISTRIBUTION}-backports" -q --force-yes firmware-misc-nonfree else - DEBIAN_FRONTEND=noninteractive apt-get install -y -q --force-yes nvidia-open-kernel-dkms - DEBIAN_FRONTEND=noninteractive apt-get install -y -q --force-yes nvidia-driver - DEBIAN_FRONTEND=noninteractive apt-get install -y -q --force-yes firmware-misc-nonfree + NVIDIA_DEB_VERSION="550.163.01-4~bpo13+1" + apt-get -o Dir::Etc::SourceParts="${DEBIAN_SNAPSHOT_DIR}" -o Acquire::Retries=5 update + DEBIAN_FRONTEND=noninteractive apt-get install -y -q -o Dir::Etc::SourceParts="${DEBIAN_SNAPSHOT_DIR}" \ + -o Acquire::Retries=5 -t ${DEBIAN_DISTRIBUTION}-backports \ + "nvidia-open-kernel-dkms=${NVIDIA_DEB_VERSION}" \ + "nvidia-driver=${NVIDIA_DEB_VERSION}" || exit 1 + DEBIAN_FRONTEND=noninteractive apt-get install -y -q firmware-misc-nonfree + apt-mark hold nvidia-open-kernel-dkms nvidia-driver fi fi # End of Install kernel diff --git a/gigabyte-ampere-cuttlefish-installer/preseed/debian-snapshot.list b/gigabyte-ampere-cuttlefish-installer/preseed/debian-snapshot.list new file mode 100644 index 00000000000..76d2a73bffb --- /dev/null +++ b/gigabyte-ampere-cuttlefish-installer/preseed/debian-snapshot.list @@ -0,0 +1 @@ +deb [check-valid-until=no] https://snapshot.debian.org/archive/debian/20260315T022902Z/ trixie-backports main contrib non-free non-free-firmware diff --git a/gigabyte-ampere-cuttlefish-installer/preseed/preseed.cfg b/gigabyte-ampere-cuttlefish-installer/preseed/preseed.cfg index 83458ad8d03..206967eb647 100644 --- a/gigabyte-ampere-cuttlefish-installer/preseed/preseed.cfg +++ b/gigabyte-ampere-cuttlefish-installer/preseed/preseed.cfg @@ -201,7 +201,7 @@ d-i partman-auto/expert_recipe_linaro_lvm_nopv string \ method{ efi } format{ } \ label { esp } \ . \ - 256 2048 4096 ext4 \ + 512 2048 4096 ext4 \ $primary{ } \ $bootable{ } \ method{ format } \ @@ -322,6 +322,8 @@ d-i grub-installer/update-nvram boolean false d-i finish-install/reboot_in_progress note d-i preseed/late_command string \ - cp -f /after_install_1.sh /target/root; \ + mkdir -p /target/root/debian-snapshot && \ + cp -f /debian-snapshot.list /target/root/debian-snapshot/ && \ + cp -f /after_install_1.sh /target/root && \ in-target /bin/sh /root/after_install_1.sh; From e25a3af0687305101dae3a95f4294acf9d2a1a18 Mon Sep 17 00:00:00 2001 From: Dmitrii Merkurev Date: Wed, 29 Jul 2026 19:38:48 +0100 Subject: [PATCH 20/53] cloud-init-image-for-cuttlefish: pin kernel and NVIDIA driver Install kernel 6.18.15-1~bpo13+1 and the matching NVIDIA driver 550.163.01-4~bpo13+1 from a snapshot.debian.org archive snapshot, matching the versions pinned by the preseed installer The Debian cloud image enables trixie-backports by default, so the pinned versions are installed unconditionally rather than gated on backports detection Bug: 537008147 Signed-off-by: Dmitrii Merkurev --- cloud-init-image-for-cuttlefish/user-data | 45 ++++++++++++----------- 1 file changed, 24 insertions(+), 21 deletions(-) diff --git a/cloud-init-image-for-cuttlefish/user-data b/cloud-init-image-for-cuttlefish/user-data index 460a0f1b03f..d590591fb23 100644 --- a/cloud-init-image-for-cuttlefish/user-data +++ b/cloud-init-image-for-cuttlefish/user-data @@ -22,6 +22,13 @@ growpart: - /dev/sda1 write_files: + - path: /etc/apt/sources.list.d/debian-snapshot.list + permissions: '0644' + owner: root:root + content: | + # Frozen snapshot: pins the kernel and NVIDIA versions installed by + # after_install_1.sh; bump the timestamp and those versions together. + deb [check-valid-until=no] https://snapshot.debian.org/archive/debian/20260315T022902Z/ trixie-backports main contrib non-free non-free-firmware - path: /root/after_install_1.sh permissions: '0755' owner: root:root @@ -55,38 +62,34 @@ write_files: # Install kernel DEBIAN_DISTRIBUTION="$(lsb_release -c -s)" - #apt-get install -y '^linux-image-6.1.*aosp14-linaro.*' '^linux-headers-6.1.*aosp14-linaro.*' - has_backports=$(apt-cache policy | grep "${DEBIAN_DISTRIBUTION}-backports") - if [ x"$has_backports" != x"" ]; then - apt install -y -t "${DEBIAN_DISTRIBUTION}-backports" "linux-headers-${DEBIAN_ARCH}" - apt install -y -t "${DEBIAN_DISTRIBUTION}-backports" "linux-image-${DEBIAN_ARCH}" - fi + KERNEL_ABI="6.18.15+deb13-arm64" + KERNEL_DEB_VERSION="6.18.15-1~bpo13+1" + NVIDIA_DEB_VERSION="550.163.01-4~bpo13+1" + apt-get -o Acquire::Retries=5 update + apt-get install -y -o Acquire::Retries=5 \ + "linux-image-${KERNEL_ABI}=${KERNEL_DEB_VERSION}" \ + "linux-headers-${KERNEL_ABI}=${KERNEL_DEB_VERSION}" || exit 1 # Install nVidia or AMD GPU driver nvidia_gpu=$(lspci | grep -i nvidia) amd_gpu=$(lspci | grep VGA | grep AMD) if [ x"$amd_gpu" != x"" ]; then # # Install amd firmware - # if [ x"$has_backports" != x"" ]; then - # apt-get install -y -t ${DEBIAN_DISTRIBUTION}-backports firmware-amd-graphics - # else - # apt-get install -y firmware-amd-graphics - # fi + # apt-get install -y firmware-amd-graphics # sed -i 's/GRUB_CMDLINE_LINUX_DEFAULT=\"\(.*\)\"/GRUB_CMDLINE_LINUX_DEFAULT=\"\1 amdgpu.runpm=0 amdgpu.dc=0\"/' /etc/default/grub # dpkg-reconfigure -fnoninteractive "grub-efi-${DEBIAN_ARCH}" echo "AMD GPU detected — skipping GPU driver installation." elif [ x"$nvidia_gpu" != x"" ]; then - # Install nvidia driver - if [ x"$has_backports" != x"" ]; then - DEBIAN_FRONTEND=noninteractive apt-get install -y -t "${DEBIAN_DISTRIBUTION}-backports" -q --force-yes nvidia-kernel-dkms - DEBIAN_FRONTEND=noninteractive apt-get install -y -t "${DEBIAN_DISTRIBUTION}-backports" -q --force-yes nvidia-driver - DEBIAN_FRONTEND=noninteractive apt-get install -y -t "${DEBIAN_DISTRIBUTION}-backports" -q --force-yes firmware-misc-nonfree - else - DEBIAN_FRONTEND=noninteractive apt-get install -y -q --force-yes nvidia-open-kernel-dkms - DEBIAN_FRONTEND=noninteractive apt-get install -y -q --force-yes nvidia-driver - DEBIAN_FRONTEND=noninteractive apt-get install -y -q --force-yes firmware-misc-nonfree - fi + # Install nvidia driver, pinned to the version validated against the + # pinned kernel. + DEBIAN_FRONTEND=noninteractive apt-get install -y -q -o Acquire::Retries=5 \ + -t "${DEBIAN_DISTRIBUTION}-backports" \ + "nvidia-open-kernel-dkms=${NVIDIA_DEB_VERSION}" \ + "nvidia-driver=${NVIDIA_DEB_VERSION}" || exit 1 + DEBIAN_FRONTEND=noninteractive apt-get install -y -q firmware-misc-nonfree + apt-mark hold nvidia-open-kernel-dkms nvidia-driver fi + rm -f /etc/apt/sources.list.d/debian-snapshot.list # End of Install kernel # Install android cuttlefish packages From 23edd528687c37afaf0cf9350008ee1be14a91a9 Mon Sep 17 00:00:00 2001 From: Dmitrii Merkurev Date: Tue, 28 Jul 2026 11:58:54 +0100 Subject: [PATCH 21/53] gigabyte-ampere-cuttlefish-installer: enable ARM64 nested virtualization Append kvm-arm.mode=nested to GRUB command line so installed hosts boot with KVM nested virtualization (NV2) enabled if available Bug: 537008147 Signed-off-by: Dmitrii Merkurev --- .../preseed/after_install_1.sh | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/gigabyte-ampere-cuttlefish-installer/preseed/after_install_1.sh b/gigabyte-ampere-cuttlefish-installer/preseed/after_install_1.sh index a3cddc67bcc..8ccdc129d90 100755 --- a/gigabyte-ampere-cuttlefish-installer/preseed/after_install_1.sh +++ b/gigabyte-ampere-cuttlefish-installer/preseed/after_install_1.sh @@ -27,6 +27,12 @@ DEBIAN_DISTRIBUTION="$(lsb_release -c -s)" DEBIAN_SNAPSHOT_DIR="/root/debian-snapshot" #apt-get install -y '^linux-image-6.1.*aosp14-linaro.*' '^linux-headers-6.1.*aosp14-linaro.*' has_backports=$(apt-cache policy | grep "${DEBIAN_DISTRIBUTION}-backports") +# Enable ARM64 nested virtualization (KVM NV2). +# +# Note that any VHE host honors the flag, FEAT_NV2 or not. Without FEAT_NV2 KVM +# falls back to normal VHE operation. Without a GICv3-class vGIC the flag is +# fatal - KVM initialization fails and /dev/kvm never appears. +sed -i 's/GRUB_CMDLINE_LINUX_DEFAULT=\"\(.*\)\"/GRUB_CMDLINE_LINUX_DEFAULT=\"\1 kvm-arm.mode=nested\"/' /etc/default/grub if [ x"$has_backports" != x"" ]; then apt install -y -t "${DEBIAN_DISTRIBUTION}-backports" linux-headers-arm64 apt install -y -t "${DEBIAN_DISTRIBUTION}-backports" linux-image-arm64 @@ -71,6 +77,13 @@ elif [ x"$nvidia_gpu" != x"" ]; then fi # End of Install kernel +# Regenerate grub.cfg: the kernel postinst's update-grub hook only runs when a +# kernel package is actually configured, so a no-op install above would leave +# the nested-virt cmdline out of the boot menu. +if [ -e /boot/grub/grub.cfg ]; then + update-grub || exit 1 +fi + # Install android cuttlefish packages #DEPLOY_CHANNEL= #DEPLOY_VERSION= From 54aeb868f2da5089d7208fa7ac7ed71c8decad9c Mon Sep 17 00:00:00 2001 From: "Ying-Chun Liu (PaulLiu)" Date: Sat, 18 Jul 2026 21:51:14 -0300 Subject: [PATCH 22/53] gigabyte-ampere-cuttlefish-installer: utils: download-ci-cf.sh: use JSON API The previous way to download the artifacts doesn't work. We fix it by using the latest JSON API. And also make the script more verbose on error. Signed-off-by: Ying-Chun Liu (PaulLiu) --- .../utils/download-ci-cf.sh | 18 ++++++++++++++++-- 1 file changed, 16 insertions(+), 2 deletions(-) diff --git a/gigabyte-ampere-cuttlefish-installer/utils/download-ci-cf.sh b/gigabyte-ampere-cuttlefish-installer/utils/download-ci-cf.sh index 22f5162b01a..3872c447c5a 100755 --- a/gigabyte-ampere-cuttlefish-installer/utils/download-ci-cf.sh +++ b/gigabyte-ampere-cuttlefish-installer/utils/download-ci-cf.sh @@ -6,9 +6,23 @@ set -o errexit URL=https://ci.android.com/builds/latest/branches/aosp-android-latest-release/targets/aosp_cf_arm64_only_phone-userdebug/view/BUILD_INFO RURL=$(curl -Ls -o /dev/null -w %{url_effective} ${URL}) -echo $RURL +echo "RURL = ${RURL}" -FILENAME=$(wget -nv -O - ${RURL%/view/BUILD_INFO}/ | grep aosp_cf_arm64_only_phone-img- | sed 's/.*\(aosp_cf_arm64_only_phone-img-[0-9]*[.]zip\).*/\1/g') +BUILD_ID=$(echo "${RURL}" | sed -n 's/.*\/builds\/submitted\/\([^\/]*\)\/.*/\1/p') +echo "BUILD_ID = ${BUILD_ID}" + +if [[ -z "${BUILD_ID}" ]]; then + echo "Error: BUILD_ID empty." + exit 1 +fi + +FILENAME="aosp_cf_arm64_only_phone-img-${BUILD_ID}.zip" +echo "FILENAME = ${FILENAME}" + +if [[ -z "${FILENAME}" ]]; then + echo "Error: FILENAME empty." + exit 1 +fi wget -nv -c ${RURL%/view/BUILD_INFO}/raw/${FILENAME} wget -nv -c ${RURL%/view/BUILD_INFO}/raw/cvd-host_package.tar.gz From 8d7ad939b38ee8a03e7b7cb06a5a7899d8d07b95 Mon Sep 17 00:00:00 2001 From: Dmitrii Merkurev Date: Fri, 31 Jul 2026 23:30:43 +0100 Subject: [PATCH 23/53] gigabyte-ampere-cuttlefish-installer: stop preinstalling kernels in the preseed check environment The check container installed linux-image-arm64 and linux-headers-arm64 from the live trixie/trixie-security archives. Real installer targets never have trixie headers, and their presence makes DKMS build the pinned NVIDIA driver against whatever kernel trixie-security shipped that day - an unpinned moving target. This broke on 2026-07-31 when Debian published 6.12.100, which the 550.163.01 driver fails to compile against, failing the nvidia matrix cell. With no stray kernels the block under test provides its own pinned kernel and DKMS builds only against the pinned, snapshot-frozen headers. Verified: the failing cell reproduced against 6.12.100 headers, and the same block passes with them absent (module builds and installs for 6.18.15). Bug: 537008147 Signed-off-by: Dmitrii Merkurev --- .../action.yaml | 1 - 1 file changed, 1 deletion(-) diff --git a/.github/actions/gigabyte-ampere-cuttlefish-installer-check-preseed-after-install-script/action.yaml b/.github/actions/gigabyte-ampere-cuttlefish-installer-check-preseed-after-install-script/action.yaml index f31c36df9a1..83c81bf2419 100644 --- a/.github/actions/gigabyte-ampere-cuttlefish-installer-check-preseed-after-install-script/action.yaml +++ b/.github/actions/gigabyte-ampere-cuttlefish-installer-check-preseed-after-install-script/action.yaml @@ -23,7 +23,6 @@ runs: apt-get install -y lsb-release apt-get install -y pciutils apt-get install -y apt-show-versions - apt-get install -y linux-image-arm64 linux-headers-arm64 - name: Setup base and non-free repository shell: bash run: | From 8eded800b7ce52849da8c758dddb683b6f362737 Mon Sep 17 00:00:00 2001 From: Dmitrii Merkurev Date: Tue, 4 Aug 2026 14:11:14 +0100 Subject: [PATCH 24/53] gigabyte-ampere-cuttlefish-installer: pin the workflow actions The workflow still referenced actions by tag, which the zizmor blanket policy rejects as soon as the file is touched. Pin them to the hashes the tags currently point at, keeping the same major versions so the artifact upload and download stay compatible. Bug: 537008147 Signed-off-by: Dmitrii Merkurev --- .../gigabyte-ampere-cuttlefish-installer.yaml | 30 +++++++++---------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/.github/workflows/gigabyte-ampere-cuttlefish-installer.yaml b/.github/workflows/gigabyte-ampere-cuttlefish-installer.yaml index 8e52f6694db..e9e65c0ed0d 100644 --- a/.github/workflows/gigabyte-ampere-cuttlefish-installer.yaml +++ b/.github/workflows/gigabyte-ampere-cuttlefish-installer.yaml @@ -56,7 +56,7 @@ jobs: nvidia_gpu: ["true", "false"] steps: - name: Checkout repository - uses: actions/checkout@v4 + uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4 - name: Check preseed after install script uses: ./.github/actions/gigabyte-ampere-cuttlefish-installer-check-preseed-after-install-script with: @@ -72,11 +72,11 @@ jobs: image: debian@sha256:13f29b6806e531c3ff3b565bb6eed73f2132506c8c9d41bb996065ca20fb27f2 # debian:trixie-20260223 (amd64) steps: - name: Checkout repository - uses: actions/checkout@v4 + uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4 - name: Build iso installer uses: ./.github/actions/build-gigabyte-ampere-cuttlefish-installer - name: Upload artifacts - uses: actions/upload-artifact@v4 + uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4 with: name: gigabyte-ampere-cuttlefish-installer-artifacts path: gigabyte-ampere-cuttlefish-installer/preseed-mini.iso.xz @@ -93,9 +93,9 @@ jobs: TEST_DISK_SIZE: "10G" steps: - name: Checkout repository - uses: actions/checkout@v4 + uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4 - name: Download artifacts - uses: actions/download-artifact@v4 + uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4 with: name: gigabyte-ampere-cuttlefish-installer-artifacts - name: Prepare test environment @@ -137,9 +137,9 @@ jobs: working-directory: ./gigabyte-ampere-cuttlefish-installer steps: - name: Checkout repository - uses: actions/checkout@v4 + uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4 - name: Download artifacts - uses: actions/download-artifact@v4 + uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4 with: name: gigabyte-ampere-cuttlefish-installer-artifacts - name: Prepare test environment @@ -185,9 +185,9 @@ jobs: working-directory: ./gigabyte-ampere-cuttlefish-installer steps: - name: Checkout repository - uses: actions/checkout@v4 + uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4 - name: Download artifacts - uses: actions/download-artifact@v4 + uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4 with: name: gigabyte-ampere-cuttlefish-installer-artifacts - name: Prepare test environment @@ -233,9 +233,9 @@ jobs: working-directory: ./gigabyte-ampere-cuttlefish-installer steps: - name: Checkout repository - uses: actions/checkout@v4 + uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4 - name: Download artifacts - uses: actions/download-artifact@v4 + uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4 with: name: gigabyte-ampere-cuttlefish-installer-artifacts - name: Prepare test environment @@ -281,9 +281,9 @@ jobs: working-directory: ./gigabyte-ampere-cuttlefish-installer steps: - name: Checkout repository - uses: actions/checkout@v4 + uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4 - name: Download artifacts - uses: actions/download-artifact@v4 + uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4 with: name: gigabyte-ampere-cuttlefish-installer-artifacts - name: Prepare test environment @@ -361,9 +361,9 @@ jobs: working-directory: ./gigabyte-ampere-cuttlefish-installer steps: - name: Checkout repository - uses: actions/checkout@v4 + uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4 - name: Download artifacts - uses: actions/download-artifact@v4 + uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4 with: name: gigabyte-ampere-cuttlefish-installer-artifacts - name: Prepare test environment From ee01e255be1f797b62a8007ca2bf4179fddfd118 Mon Sep 17 00:00:00 2001 From: Dmitrii Merkurev Date: Tue, 4 Aug 2026 14:11:14 +0100 Subject: [PATCH 25/53] gigabyte-ampere-cuttlefish-installer: wait for the vm to finish booting The qemu test jobs treat the serial console login prompt as "vm is ready" and ssh into the guest right away. The prompt only means getty started: the guest is still booting, so the ssh handshake gets reset (kex_exchange_identification: read: Connection reset by peer) and, once that is past, dns is not up yet for the first command needing it. The console is polled every 30s, so the ssh always lands at the same point after boot and whether it works is luck. Four of twelve job instances across six recent runs failed this way, on both jobs and regardless of which kernel the installer had put on the vm. Wait until systemd reports the boot finished before using the vm. Bug: 537008147 Signed-off-by: Dmitrii Merkurev --- .github/workflows/gigabyte-ampere-cuttlefish-installer.yaml | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/.github/workflows/gigabyte-ampere-cuttlefish-installer.yaml b/.github/workflows/gigabyte-ampere-cuttlefish-installer.yaml index e9e65c0ed0d..32ef8127919 100644 --- a/.github/workflows/gigabyte-ampere-cuttlefish-installer.yaml +++ b/.github/workflows/gigabyte-ampere-cuttlefish-installer.yaml @@ -301,6 +301,9 @@ jobs: run: | screen -d -m -L -Logfile console_001.log ./installer-iso-run-qemu.sh while ! egrep "[^[:space:]]+[[:space:]]login:" console_001.log; do sleep 30; done + # The login prompt appears before the system is usable, so wait for the + # boot to complete. "degraded" means booted with some unit failed. + until sshpass -p cuttlefish ssh -o "StrictHostKeyChecking no" -o "UserKnownHostsFile /dev/null" -o "ConnectTimeout 60" -p 33322 vsoc-01@localhost 'systemctl is-system-running | grep -qE "running|degraded"'; do sleep 30; done cp -f console_001.log console_001_p1.log CONSOLELINES=$(cat console_001_p1.log | wc -l) cat console_001_p1.log @@ -381,6 +384,9 @@ jobs: run: | screen -d -m -L -Logfile console_001.log ./installer-iso-run-qemu.sh while ! egrep "[^[:space:]]+[[:space:]]login:" console_001.log; do sleep 30; done + # The login prompt appears before the system is usable, so wait for the + # boot to complete. "degraded" means booted with some unit failed. + until sshpass -p cuttlefish ssh -o "StrictHostKeyChecking no" -o "UserKnownHostsFile /dev/null" -o "ConnectTimeout 60" -p 33322 vsoc-01@localhost 'systemctl is-system-running | grep -qE "running|degraded"'; do sleep 30; done cp -f console_001.log console_001_p1.log CONSOLELINES=$(cat console_001_p1.log | wc -l) cat console_001_p1.log From 4a44a705a3f36fcf43b4e4f6b05f7b953b790ccd Mon Sep 17 00:00:00 2001 From: Dmitrii Merkurev Date: Wed, 5 Aug 2026 01:35:00 +0100 Subject: [PATCH 26/53] gigabyte-ampere-cuttlefish-installer: resolve the build id via status.json The /builds/latest/ redirect the script followed is rate limited and returns 403 once the quota is exhausted, failing the download. Read the id from the target's status.json instead, which is not on that quota, and build the artifact URLs from it directly. Bug: 537008147 Signed-off-by: Dmitrii Merkurev --- .../utils/download-ci-cf.sh | 19 ++++++++----------- 1 file changed, 8 insertions(+), 11 deletions(-) diff --git a/gigabyte-ampere-cuttlefish-installer/utils/download-ci-cf.sh b/gigabyte-ampere-cuttlefish-installer/utils/download-ci-cf.sh index 3872c447c5a..62d1594b175 100755 --- a/gigabyte-ampere-cuttlefish-installer/utils/download-ci-cf.sh +++ b/gigabyte-ampere-cuttlefish-installer/utils/download-ci-cf.sh @@ -4,11 +4,11 @@ set -o errexit -URL=https://ci.android.com/builds/latest/branches/aosp-android-latest-release/targets/aosp_cf_arm64_only_phone-userdebug/view/BUILD_INFO -RURL=$(curl -Ls -o /dev/null -w %{url_effective} ${URL}) -echo "RURL = ${RURL}" - -BUILD_ID=$(echo "${RURL}" | sed -n 's/.*\/builds\/submitted\/\([^\/]*\)\/.*/\1/p') +BRANCH=aosp-android-latest-release +TARGET=aosp_cf_arm64_only_phone-userdebug +BUILD_ID=$(curl -fsS \ + "https://ci.android.com/builds/branches/${BRANCH}/targets/${TARGET}/status.json" \ + | sed -n 's/.*[{,[:space:]]"last_known_good_build"[[:space:]]*:[[:space:]]*"\([0-9][0-9]*\)".*/\1/p') echo "BUILD_ID = ${BUILD_ID}" if [[ -z "${BUILD_ID}" ]]; then @@ -19,12 +19,9 @@ fi FILENAME="aosp_cf_arm64_only_phone-img-${BUILD_ID}.zip" echo "FILENAME = ${FILENAME}" -if [[ -z "${FILENAME}" ]]; then - echo "Error: FILENAME empty." - exit 1 -fi +RAWURL="https://ci.android.com/builds/submitted/${BUILD_ID}/${TARGET}/latest/raw" -wget -nv -c ${RURL%/view/BUILD_INFO}/raw/${FILENAME} -wget -nv -c ${RURL%/view/BUILD_INFO}/raw/cvd-host_package.tar.gz +wget -nv -c ${RAWURL}/${FILENAME} +wget -nv -c ${RAWURL}/cvd-host_package.tar.gz exit 0 From cf53c344419fe9d2b7bc8c6bbc910bc22028d74d Mon Sep 17 00:00:00 2001 From: Ram Muthiah Date: Mon, 29 Jun 2026 08:11:48 -0700 Subject: [PATCH 27/53] Cherry-pick of ag/40371614 Fix netsim vsock proxy parameters for vhost-user-vsock Cuttlefish host launcher run_cvd fails to pass --vhost_user_vsock=true to socket_vsock_proxy helper processes (hci_vsock_proxy and test_vsock_proxy). This results in the proxy processes binding to the host kernel vsock interface rather than the vhost-user Unix domain socket when vhost_user_vsock is enabled, causing guest vsock connections to hang. Bug: b/520342656 Test: Manual verification on CF target with vhost-user-vsock --- .../host/commands/run_cvd/launch/netsim_server.cpp | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/base/cvd/cuttlefish/host/commands/run_cvd/launch/netsim_server.cpp b/base/cvd/cuttlefish/host/commands/run_cvd/launch/netsim_server.cpp index f684cf87238..cf4c0ec6917 100644 --- a/base/cvd/cuttlefish/host/commands/run_cvd/launch/netsim_server.cpp +++ b/base/cvd/cuttlefish/host/commands/run_cvd/launch/netsim_server.cpp @@ -137,6 +137,9 @@ class NetsimServer : public CommandSource { hci_vsock_proxy.AddParameter("--client_tcp_host=127.0.0.1"); hci_vsock_proxy.AddParameter("--client_tcp_port=", config_.rootcanal_hci_port()); + if (instance_.vhost_user_vsock()) { + hci_vsock_proxy.AddParameter("--vhost_user_vsock=true"); + } // Add command for forwarding the test port to a vsock server. Command test_vsock_proxy(SocketVsockProxyBinary()); @@ -149,6 +152,9 @@ class NetsimServer : public CommandSource { test_vsock_proxy.AddParameter("--client_tcp_host=127.0.0.1"); test_vsock_proxy.AddParameter("--client_tcp_port=", config_.rootcanal_test_port()); + if (instance_.vhost_user_vsock()) { + test_vsock_proxy.AddParameter("--vhost_user_vsock=true"); + } std::vector commands; commands.emplace_back(std::move(netsimd)); From 3c72c358a77c98c76911fad7c22a264c09d54037 Mon Sep 17 00:00:00 2001 From: Bill Schilit Date: Mon, 13 Jul 2026 20:42:39 +0000 Subject: [PATCH 28/53] Add netsim_modem CLI flag and route cellular modem over VSOCK to netsimd Enables netsim to act as the cellular modem simulator for Cuttlefish by passing VSOCK connections directly to netsimd: 1. CLI & Instance Configuration: - Adds '--netsim_modem' flag to launch_cvd to route cellular modem traffic to netsim. - Disables the legacy standalone modem_simulator process when '--netsim_modem' or '--netsim' is active. - Records modem simulator instance count and SIM type in CuttlefishConfig. 2. VSOCK Server Routing ('netsim_server.cpp'): - Creates a VSOCK server socket ('SharedFD::VsockServer') listening on each guest modem simulator port. - Configures the CELLULAR chip in netsimd's startup JSON ('-s'), passing the inherited listening file descriptor as 'vsockFd' and the SIM configuration as 'simType'. Refactored netsim radio enabling to use per-instance config checks in netsim_server.cpp to support mixed-mode multi-instance clusters, and removed the global netsim_radio_enabled config. Bug: 514348948 Bug: 530300761 Bug: 532125591 Test: launch_cvd --netsim_modem --- .../assemble_cvd/assemble_cvd_flags.cpp | 2 + .../assemble_cvd/assemble_cvd_flags.h | 1 + .../commands/assemble_cvd/bootconfig_args.cpp | 6 +- .../host/commands/assemble_cvd/flags.cc | 34 ++----- .../commands/assemble_cvd/flags_defaults.h | 1 + .../cvd/cli/parser/golang/load_config.pb.go | 92 ++++++++++++++----- .../cvd/cli/parser/launch_cvd_parser.cpp | 4 + .../commands/cvd/cli/parser/load_config.proto | 2 + .../host/commands/run_cvd/launch/BUILD.bazel | 1 + .../commands/run_cvd/launch/netsim_server.cpp | 60 ++++++++++-- .../host/libs/config/cuttlefish_config.cpp | 15 --- .../host/libs/config/cuttlefish_config.h | 12 +-- .../config/cuttlefish_config_instance.cpp | 9 ++ 13 files changed, 159 insertions(+), 80 deletions(-) diff --git a/base/cvd/cuttlefish/host/commands/assemble_cvd/assemble_cvd_flags.cpp b/base/cvd/cuttlefish/host/commands/assemble_cvd/assemble_cvd_flags.cpp index 826ceb7b0e9..96778f9bdec 100644 --- a/base/cvd/cuttlefish/host/commands/assemble_cvd/assemble_cvd_flags.cpp +++ b/base/cvd/cuttlefish/host/commands/assemble_cvd/assemble_cvd_flags.cpp @@ -142,6 +142,8 @@ DEFINE_vec(netsim_uwb, fmt::format("{}", CF_DEFAULTS_NETSIM_UWB), "[Experimental] Connect Uwb radio to netsim."); DEFINE_vec(netsim_nfc, fmt::format("{}", CF_DEFAULTS_NETSIM_NFC), "[Experimental] Connect Nfc radio to netsim."); +DEFINE_vec(netsim_modem, fmt::format("{}", CF_DEFAULTS_NETSIM_MODEM), + "[Experimental] Connect Modem radio to netsim."); DEFINE_string(netsim_args, CF_DEFAULTS_NETSIM_ARGS, "Space-separated list of netsim args."); diff --git a/base/cvd/cuttlefish/host/commands/assemble_cvd/assemble_cvd_flags.h b/base/cvd/cuttlefish/host/commands/assemble_cvd/assemble_cvd_flags.h index bb4c32857c8..d0501b7fde3 100644 --- a/base/cvd/cuttlefish/host/commands/assemble_cvd/assemble_cvd_flags.h +++ b/base/cvd/cuttlefish/host/commands/assemble_cvd/assemble_cvd_flags.h @@ -69,6 +69,7 @@ DECLARE_vec(netsim); DECLARE_vec(netsim_bt); DECLARE_vec(netsim_uwb); DECLARE_vec(netsim_nfc); +DECLARE_vec(netsim_modem); DECLARE_string(netsim_args); DECLARE_bool(enable_automotive_proxy); diff --git a/base/cvd/cuttlefish/host/commands/assemble_cvd/bootconfig_args.cpp b/base/cvd/cuttlefish/host/commands/assemble_cvd/bootconfig_args.cpp index b23de528129..ce76330e796 100644 --- a/base/cvd/cuttlefish/host/commands/assemble_cvd/bootconfig_args.cpp +++ b/base/cvd/cuttlefish/host/commands/assemble_cvd/bootconfig_args.cpp @@ -231,7 +231,11 @@ Result> BootconfigArgsFromConfig( std::to_string(instance.vsock_guest_cid()); } - if (instance.enable_modem_simulator() && + // Export modem simulator ports for both standalone modem_simulator and + // netsim. The guest RIL (ag/40529282) polls ro.boot.modem_simulator_ports on + // startup to connect over VSOCK regardless of which daemon handles the host + // connection. + if ((instance.enable_modem_simulator() || instance.enable_modem_netsim()) && !instance.modem_simulator_ports().empty()) { bootconfig_args["androidboot.modem_simulator_ports"] = instance.modem_simulator_ports(); diff --git a/base/cvd/cuttlefish/host/commands/assemble_cvd/flags.cc b/base/cvd/cuttlefish/host/commands/assemble_cvd/flags.cc index 50bf154a74c..dc2912fb11a 100644 --- a/base/cvd/cuttlefish/host/commands/assemble_cvd/flags.cc +++ b/base/cvd/cuttlefish/host/commands/assemble_cvd/flags.cc @@ -456,9 +456,6 @@ Result InitializeCuttlefishConfiguration( tmp_config_obj.set_ap_rootfs_image(ap_rootfs_image); tmp_config_obj.set_ap_kernel_image(FLAGS_ap_kernel_image); - tmp_config_obj.set_enable_host_nfc(FLAGS_enable_host_nfc); - tmp_config_obj.set_enable_host_nfc_connector(FLAGS_enable_host_nfc); - // get flag default values and store into map auto name_to_default_value = CurrentFlagsToDefaultValue(); // old flags but vectorized for multi-device instances @@ -467,33 +464,15 @@ Result InitializeCuttlefishConfiguration( // netsim flags allow all radios or selecting a specific radio std::vector netsim_all_radios_vec = CF_EXPECT(GET_FLAG_BOOL_VALUE(netsim)); - bool any_netsim_all_radios = - std::any_of(netsim_all_radios_vec.begin(), netsim_all_radios_vec.end(), - [](bool e) { return e; }); std::vector netsim_bt_vec = CF_EXPECT(GET_FLAG_BOOL_VALUE(netsim_bt)); - bool any_netsim_bt = std::any_of(netsim_bt_vec.begin(), netsim_bt_vec.end(), - [](bool e) { return e; }); std::vector netsim_uwb_vec = CF_EXPECT(GET_FLAG_BOOL_VALUE(netsim_uwb)); bool any_netsim_uwb = std::any_of( netsim_uwb_vec.begin(), netsim_uwb_vec.end(), [](bool e) { return e; }); std::vector netsim_nfc_vec = CF_EXPECT(GET_FLAG_BOOL_VALUE(netsim_nfc)); bool any_netsim_nfc = std::any_of( netsim_nfc_vec.begin(), netsim_nfc_vec.end(), [](bool e) { return e; }); - bool netsim_has_bt = any_netsim_all_radios || any_netsim_bt; - bool netsim_has_uwb = any_netsim_all_radios || any_netsim_uwb; - bool netsim_has_nfc = any_netsim_all_radios || any_netsim_nfc; - - // These flags inform NetsimServer::ResultSetup which radios it owns. - if (netsim_has_bt) { - tmp_config_obj.netsim_radio_enable( - CuttlefishConfig::NetsimRadio::Bluetooth); - } - if (netsim_has_uwb) { - tmp_config_obj.netsim_radio_enable(CuttlefishConfig::NetsimRadio::Uwb); - } - if (netsim_has_nfc) { - tmp_config_obj.netsim_radio_enable(CuttlefishConfig::NetsimRadio::Nfc); - } + std::vector netsim_modem_vec = + CF_EXPECT(GET_FLAG_BOOL_VALUE(netsim_modem)); bool any_not_netsim_bt = false; bool any_not_netsim_uwb = false; @@ -1027,9 +1006,12 @@ Result InitializeCuttlefishConfiguration( guest_enforce_security_values.ForIndex(instance_index)); instance.set_pause_in_bootloader(pause_in_bootloader_vec[instance_index]); instance.set_run_as_daemon(daemon_values.ForIndex(instance_index)); + bool is_modem_netsim = netsim_all_radios_vec[instance_index] || + netsim_modem_vec[instance_index]; instance.set_enable_modem_simulator( enable_modem_simulator_vec[instance_index] && - !enable_minimal_mode_vec[instance_index]); + !enable_minimal_mode_vec[instance_index] && !is_modem_netsim); + instance.set_enable_modem_netsim(is_modem_netsim); instance.set_modem_simulator_instance_number( modem_simulator_count_vec[instance_index]); instance.set_modem_simulator_sim_type( @@ -1085,7 +1067,9 @@ Result InitializeCuttlefishConfiguration( instance.set_enable_host_uwb_connector(FLAGS_enable_host_uwb && !is_uwb_netsim); - bool is_any_netsim = is_netsim_all || is_bt_netsim || is_uwb_netsim; + bool is_nfc_netsim = is_netsim_all || netsim_nfc_vec[instance_index]; + bool is_any_netsim = is_netsim_all || is_bt_netsim || is_uwb_netsim || + is_nfc_netsim || is_modem_netsim; instance.set_uuid(uuid_vec[instance_index]); diff --git a/base/cvd/cuttlefish/host/commands/assemble_cvd/flags_defaults.h b/base/cvd/cuttlefish/host/commands/assemble_cvd/flags_defaults.h index 8b47a93d487..cb10cfbbb69 100644 --- a/base/cvd/cuttlefish/host/commands/assemble_cvd/flags_defaults.h +++ b/base/cvd/cuttlefish/host/commands/assemble_cvd/flags_defaults.h @@ -175,6 +175,7 @@ #define CF_DEFAULTS_NETSIM_BT true #define CF_DEFAULTS_NETSIM_UWB true #define CF_DEFAULTS_NETSIM_NFC false +#define CF_DEFAULTS_NETSIM_MODEM false // Netsim default parameters #define CF_DEFAULTS_NETSIM_ARGS "" diff --git a/base/cvd/cuttlefish/host/commands/cvd/cli/parser/golang/load_config.pb.go b/base/cvd/cuttlefish/host/commands/cvd/cli/parser/golang/load_config.pb.go index 66cc46d4f09..8006029776b 100644 --- a/base/cvd/cuttlefish/host/commands/cvd/cli/parser/golang/load_config.pb.go +++ b/base/cvd/cuttlefish/host/commands/cvd/cli/parser/golang/load_config.pb.go @@ -1,7 +1,22 @@ +// +// Copyright (C) 2024 The Android Open Source Project +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.36.10 -// protoc v6.33.0 +// protoc-gen-go v1.36.11 +// protoc v3.21.12 // source: cuttlefish/host/commands/cvd/cli/parser/load_config.proto package golang @@ -21,12 +36,18 @@ const ( _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) ) +// Specifies the emulated user space page size. type UserPageSize int32 const ( + // Kernel page size will be used. UserPageSize_USER_PAGE_SIZE_UNSPECIFIED UserPageSize = 0 - UserPageSize_USER_PAGE_SIZE_16KB UserPageSize = 1 - UserPageSize_USER_PAGE_SIZE_64KB UserPageSize = 2 + // Request a 16KB page size. + // On x86_64, this implies emulation via kernel command line (e.g., + // page_shift=14). + UserPageSize_USER_PAGE_SIZE_16KB UserPageSize = 1 + // Request a 64KB page size. + UserPageSize_USER_PAGE_SIZE_64KB UserPageSize = 2 ) // Enum value maps for UserPageSize. @@ -128,6 +149,7 @@ type EnvironmentSpecification struct { NetsimBt *bool `protobuf:"varint,5,opt,name=netsim_bt,json=netsimBt,proto3,oneof" json:"netsim_bt,omitempty"` NetsimUwb *bool `protobuf:"varint,6,opt,name=netsim_uwb,json=netsimUwb,proto3,oneof" json:"netsim_uwb,omitempty"` NetsimArgs []string `protobuf:"bytes,7,rep,name=netsim_args,json=netsimArgs,proto3" json:"netsim_args,omitempty"` + NetsimModem *bool `protobuf:"varint,8,opt,name=netsim_modem,json=netsimModem,proto3,oneof" json:"netsim_modem,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } @@ -211,6 +233,15 @@ func (x *EnvironmentSpecification) GetNetsimArgs() []string { return nil } +func (x *EnvironmentSpecification) GetNetsimModem() bool { + if x != nil && x.NetsimModem != nil { + return *x.NetsimModem + } + return false +} + +// TODO: chadreynolds - when we can make breaking changes and update, use this +// in EnvironmentSpecification instead of individual fields type EnvironmentOptions struct { state protoimpl.MessageState `protogen:"open.v1"` Fetch *Fetch `protobuf:"bytes,1,opt,name=fetch,proto3,oneof" json:"fetch,omitempty"` @@ -219,6 +250,7 @@ type EnvironmentOptions struct { NetsimBt *bool `protobuf:"varint,4,opt,name=netsim_bt,json=netsimBt,proto3,oneof" json:"netsim_bt,omitempty"` NetsimUwb *bool `protobuf:"varint,5,opt,name=netsim_uwb,json=netsimUwb,proto3,oneof" json:"netsim_uwb,omitempty"` NetsimArgs []string `protobuf:"bytes,6,rep,name=netsim_args,json=netsimArgs,proto3" json:"netsim_args,omitempty"` + NetsimModem *bool `protobuf:"varint,7,opt,name=netsim_modem,json=netsimModem,proto3,oneof" json:"netsim_modem,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } @@ -295,6 +327,13 @@ func (x *EnvironmentOptions) GetNetsimArgs() []string { return nil } +func (x *EnvironmentOptions) GetNetsimModem() bool { + if x != nil && x.NetsimModem != nil { + return *x.NetsimModem + } + return false +} + type Common struct { state protoimpl.MessageState `protogen:"open.v1"` GroupName *string `protobuf:"bytes,1,opt,name=group_name,json=groupName,proto3,oneof" json:"group_name,omitempty"` @@ -432,17 +471,18 @@ func (x *Fetch) GetProjectId() string { } type Instance struct { - state protoimpl.MessageState `protogen:"open.v1"` - Name *string `protobuf:"bytes,1,opt,name=name,proto3,oneof" json:"name,omitempty"` - Vm *Vm `protobuf:"bytes,2,opt,name=vm,proto3,oneof" json:"vm,omitempty"` - Boot *Boot `protobuf:"bytes,3,opt,name=boot,proto3,oneof" json:"boot,omitempty"` - Security *Security `protobuf:"bytes,4,opt,name=security,proto3,oneof" json:"security,omitempty"` - Disk *Disk `protobuf:"bytes,5,opt,name=disk,proto3,oneof" json:"disk,omitempty"` - Graphics *Graphics `protobuf:"bytes,6,opt,name=graphics,proto3,oneof" json:"graphics,omitempty"` - Streaming *Streaming `protobuf:"bytes,7,opt,name=streaming,proto3,oneof" json:"streaming,omitempty"` - Connectivity *Connectivity `protobuf:"bytes,8,opt,name=connectivity,proto3,oneof" json:"connectivity,omitempty"` - ImportTemplate *string `protobuf:"bytes,9,opt,name=import_template,json=@import,proto3,oneof" json:"import_template,omitempty"` - Media *Media `protobuf:"bytes,10,opt,name=media,proto3,oneof" json:"media,omitempty"` + state protoimpl.MessageState `protogen:"open.v1"` + Name *string `protobuf:"bytes,1,opt,name=name,proto3,oneof" json:"name,omitempty"` + Vm *Vm `protobuf:"bytes,2,opt,name=vm,proto3,oneof" json:"vm,omitempty"` + Boot *Boot `protobuf:"bytes,3,opt,name=boot,proto3,oneof" json:"boot,omitempty"` + Security *Security `protobuf:"bytes,4,opt,name=security,proto3,oneof" json:"security,omitempty"` + Disk *Disk `protobuf:"bytes,5,opt,name=disk,proto3,oneof" json:"disk,omitempty"` + Graphics *Graphics `protobuf:"bytes,6,opt,name=graphics,proto3,oneof" json:"graphics,omitempty"` + Streaming *Streaming `protobuf:"bytes,7,opt,name=streaming,proto3,oneof" json:"streaming,omitempty"` + Connectivity *Connectivity `protobuf:"bytes,8,opt,name=connectivity,proto3,oneof" json:"connectivity,omitempty"` + // TODO: b/337089452 - handle outside of proto logic + ImportTemplate *string `protobuf:"bytes,9,opt,name=import_template,json=@import,proto3,oneof" json:"import_template,omitempty"` + Media *Media `protobuf:"bytes,10,opt,name=media,proto3,oneof" json:"media,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } @@ -1362,8 +1402,9 @@ func (*V4L2EmulatedCameraMplane) Descriptor() ([]byte, []int) { } type V4L2Proxy struct { - state protoimpl.MessageState `protogen:"open.v1"` - DevicePath *string `protobuf:"bytes,1,opt,name=device_path,json=devicePath,proto3,oneof" json:"device_path,omitempty"` + state protoimpl.MessageState `protogen:"open.v1"` + // Path to a V4L2 device to expose to the guest. E.g. `/dev/video0`. + DevicePath *string `protobuf:"bytes,1,opt,name=device_path,json=devicePath,proto3,oneof" json:"device_path,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } @@ -1419,7 +1460,8 @@ type Vm struct { // *Vm_Qemu Vmm isVm_Vmm `protobuf_oneof:"vmm"` CustomActions []*CustomAction `protobuf:"bytes,9,rep,name=custom_actions,json=customActions,proto3" json:"custom_actions,omitempty"` - PageSize *UserPageSize `protobuf:"varint,10,opt,name=page_size,json=pageSize,proto3,enum=cuttlefish.cvd.config.UserPageSize,oneof" json:"page_size,omitempty"` + // Desired user space page size. + PageSize *UserPageSize `protobuf:"varint,10,opt,name=page_size,json=pageSize,proto3,enum=cuttlefish.cvd.config.UserPageSize,oneof" json:"page_size,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } @@ -1987,7 +2029,7 @@ var File_cuttlefish_host_commands_cvd_cli_parser_load_config_proto protoreflect. const file_cuttlefish_host_commands_cvd_cli_parser_load_config_proto_rawDesc = "" + "\n" + - "9cuttlefish/host/commands/cvd/cli/parser/load_config.proto\x12\x15cuttlefish.cvd.config\"\xb2\x03\n" + + "9cuttlefish/host/commands/cvd/cli/parser/load_config.proto\x12\x15cuttlefish.cvd.config\"\xeb\x03\n" + "\x18EnvironmentSpecification\x12=\n" + "\tinstances\x18\x01 \x03(\v2\x1f.cuttlefish.cvd.config.InstanceR\tinstances\x127\n" + "\x05fetch\x18\x02 \x01(\v2\x1c.cuttlefish.cvd.config.FetchH\x00R\x05fetch\x88\x01\x01\x12=\n" + @@ -1997,14 +2039,16 @@ const file_cuttlefish_host_commands_cvd_cli_parser_load_config_proto_rawDesc = " "\n" + "netsim_uwb\x18\x06 \x01(\bH\x04R\tnetsimUwb\x88\x01\x01\x12\x1f\n" + "\vnetsim_args\x18\a \x03(\tR\n" + - "netsimArgsB\b\n" + + "netsimArgs\x12&\n" + + "\fnetsim_modem\x18\b \x01(\bH\x05R\vnetsimModem\x88\x01\x01B\b\n" + "\x06_fetchB\n" + "\n" + "\b_metricsB\t\n" + "\a_commonB\f\n" + "\n" + "_netsim_btB\r\n" + - "\v_netsim_uwb\"\xed\x02\n" + + "\v_netsim_uwbB\x0f\n" + + "\r_netsim_modem\"\xa6\x03\n" + "\x12EnvironmentOptions\x127\n" + "\x05fetch\x18\x01 \x01(\v2\x1c.cuttlefish.cvd.config.FetchH\x00R\x05fetch\x88\x01\x01\x12=\n" + "\ametrics\x18\x02 \x01(\v2\x1e.cuttlefish.cvd.config.MetricsH\x01R\ametrics\x88\x01\x01\x12:\n" + @@ -2013,14 +2057,16 @@ const file_cuttlefish_host_commands_cvd_cli_parser_load_config_proto_rawDesc = " "\n" + "netsim_uwb\x18\x05 \x01(\bH\x04R\tnetsimUwb\x88\x01\x01\x12\x1f\n" + "\vnetsim_args\x18\x06 \x03(\tR\n" + - "netsimArgsB\b\n" + + "netsimArgs\x12&\n" + + "\fnetsim_modem\x18\a \x01(\bH\x05R\vnetsimModem\x88\x01\x01B\b\n" + "\x06_fetchB\n" + "\n" + "\b_metricsB\t\n" + "\a_commonB\f\n" + "\n" + "_netsim_btB\r\n" + - "\v_netsim_uwb\"t\n" + + "\v_netsim_uwbB\x0f\n" + + "\r_netsim_modem\"t\n" + "\x06Common\x12\"\n" + "\n" + "group_name\x18\x01 \x01(\tH\x00R\tgroupName\x88\x01\x01\x12&\n" + diff --git a/base/cvd/cuttlefish/host/commands/cvd/cli/parser/launch_cvd_parser.cpp b/base/cvd/cuttlefish/host/commands/cvd/cli/parser/launch_cvd_parser.cpp index ab5697933a0..9428c7a872a 100644 --- a/base/cvd/cuttlefish/host/commands/cvd/cli/parser/launch_cvd_parser.cpp +++ b/base/cvd/cuttlefish/host/commands/cvd/cli/parser/launch_cvd_parser.cpp @@ -66,6 +66,10 @@ Result> GenerateCfFlags( flags.emplace_back(GenerateFlag("netsim_uwb", launch.netsim_uwb())); } + if (launch.has_netsim_modem()) { + flags.emplace_back(GenerateFlag("netsim_modem", launch.netsim_modem())); + } + if (!launch.netsim_args().empty()) { for (const auto& arg : launch.netsim_args()) { CF_EXPECTF(arg.find_first_of(" \t\n\v\f\r") == std::string::npos, diff --git a/base/cvd/cuttlefish/host/commands/cvd/cli/parser/load_config.proto b/base/cvd/cuttlefish/host/commands/cvd/cli/parser/load_config.proto index 25ac3c436fb..51a1f9d137f 100644 --- a/base/cvd/cuttlefish/host/commands/cvd/cli/parser/load_config.proto +++ b/base/cvd/cuttlefish/host/commands/cvd/cli/parser/load_config.proto @@ -52,6 +52,7 @@ message EnvironmentSpecification { optional bool netsim_bt = 5; optional bool netsim_uwb = 6; repeated string netsim_args = 7; + optional bool netsim_modem = 8; } // TODO: chadreynolds - when we can make breaking changes and update, use this @@ -63,6 +64,7 @@ message EnvironmentOptions { optional bool netsim_bt = 4; optional bool netsim_uwb = 5; repeated string netsim_args = 6; + optional bool netsim_modem = 7; } message Common { diff --git a/base/cvd/cuttlefish/host/commands/run_cvd/launch/BUILD.bazel b/base/cvd/cuttlefish/host/commands/run_cvd/launch/BUILD.bazel index dc908fc4290..6d9b30f27f1 100644 --- a/base/cvd/cuttlefish/host/commands/run_cvd/launch/BUILD.bazel +++ b/base/cvd/cuttlefish/host/commands/run_cvd/launch/BUILD.bazel @@ -286,6 +286,7 @@ cf_cc_library( "//cuttlefish/host/libs/config:known_paths", "//cuttlefish/host/libs/feature", "//cuttlefish/result", + "//libbase", "@fruit", ], ) diff --git a/base/cvd/cuttlefish/host/commands/run_cvd/launch/netsim_server.cpp b/base/cvd/cuttlefish/host/commands/run_cvd/launch/netsim_server.cpp index cf4c0ec6917..9893456d50f 100644 --- a/base/cvd/cuttlefish/host/commands/run_cvd/launch/netsim_server.cpp +++ b/base/cvd/cuttlefish/host/commands/run_cvd/launch/netsim_server.cpp @@ -15,6 +15,11 @@ #include "cuttlefish/host/commands/run_cvd/launch/netsim_server.h" +#include +#include + +#include +#include #include #include #include @@ -56,13 +61,24 @@ class Chip { public: SharedFD fd_in; SharedFD fd_out; + SharedFD vsock_fd; + int sim_type = 1; Chip(std::string kind) : kind_(kind) {} // Append the chip information as Json to the command. void Append(Command& c) const { - c.AppendToLastParameter(R"({"kind":")", kind_, R"(","fdIn":)", fd_in, - R"(,"fdOut":)", fd_out, "}"); + if (vsock_fd->IsOpen()) { + c.AppendToLastParameter(R"({"kind":")", kind_, R"(","vsockFd":)", + vsock_fd); + } else { + c.AppendToLastParameter(R"({"kind":")", kind_, R"(","fdIn":)", fd_in, + R"(,"fdOut":)", fd_out); + } + if (kind_ == "CELLULAR") { + c.AppendToLastParameter(R"(,"simType":)", std::to_string(sim_type)); + } + c.AppendToLastParameter("}"); } private: @@ -192,27 +208,59 @@ class NetsimServer : public CommandSource { for (const auto& instance : config_.Instances()) { Device device(instance.adb_ip_and_port()); // Add bluetooth chip if enabled - if (config_.netsim_radio_enabled( - CuttlefishConfig::NetsimRadio::Bluetooth)) { + if (instance.has_bluetooth() && + !instance.enable_host_bluetooth_connector()) { Chip chip("BLUETOOTH"); chip.fd_in = CF_EXPECT(MakeFifo(instance, "bt_fifo_vm.in")); chip.fd_out = CF_EXPECT(MakeFifo(instance, "bt_fifo_vm.out")); device.chips.emplace_back(chip); } // Add uwb chip if enabled - if (config_.netsim_radio_enabled(CuttlefishConfig::NetsimRadio::Uwb)) { + if (config_.enable_host_uwb() && !instance.enable_host_uwb_connector()) { Chip chip("UWB"); chip.fd_in = CF_EXPECT(MakeFifo(instance, "uwb_fifo_vm.in")); chip.fd_out = CF_EXPECT(MakeFifo(instance, "uwb_fifo_vm.out")); device.chips.emplace_back(chip); } // Add nfc chip if enabled - if (config_.netsim_radio_enabled(CuttlefishConfig::NetsimRadio::Nfc)) { + if (config_.enable_host_nfc() && !config_.enable_host_nfc_connector()) { Chip chip("NFC"); chip.fd_in = CF_EXPECT(MakeFifo(instance, "nfc_fifo_vm.in")); chip.fd_out = CF_EXPECT(MakeFifo(instance, "nfc_fifo_vm.out")); device.chips.emplace_back(chip); } + // Add modem chip if enabled + if (instance.enable_modem_netsim()) { + // modem_count is the number of modems configured for this VM instance + int modem_count = instance.modem_simulator_instance_number(); + CF_EXPECT( + modem_count >= 0 && modem_count < 4, + "Modem simulator instance number should range between 0 and 3"); + auto port_strings = + android::base::Split(instance.modem_simulator_ports(), ","); + for (size_t i = 0; + i < static_cast(modem_count) && i < port_strings.size(); + ++i) { + int port = 0; + CF_EXPECT( + android::base::ParseInt(port_strings[i], &port), + "Failed to parse modem simulator port: " << port_strings[i]); + + auto vsock = SharedFD::VsockServer( + port, SOCK_STREAM, + instance.vhost_user_vsock() + ? std::make_optional(instance.vsock_guest_cid()) + : std::nullopt); + CF_EXPECT(vsock->IsOpen(), vsock->StrError() + << " (try `cvd reset`, or `pkill " + "run_cvd` and `pkill crosvm`)"); + + Chip chip("CELLULAR"); + chip.vsock_fd = vsock; + chip.sim_type = instance.modem_simulator_sim_type(); + device.chips.emplace_back(chip); + } + } // Add other chips if enabled devices_.emplace_back(device); } diff --git a/base/cvd/cuttlefish/host/libs/config/cuttlefish_config.cpp b/base/cvd/cuttlefish/host/libs/config/cuttlefish_config.cpp index 3e545b1cb96..b4b02251775 100644 --- a/base/cvd/cuttlefish/host/libs/config/cuttlefish_config.cpp +++ b/base/cvd/cuttlefish/host/libs/config/cuttlefish_config.cpp @@ -269,21 +269,6 @@ int CuttlefishConfig::casimir_rf_port() const { return (*dictionary_)[kCasimirRfPort].asInt(); } -static constexpr char kNetsimRadios[] = "netsim_radios"; - -void CuttlefishConfig::netsim_radio_enable(NetsimRadio flag) { - if (dictionary_->isMember(kNetsimRadios)) { - // OR the radio to current set of radios - (*dictionary_)[kNetsimRadios] = (*dictionary_)[kNetsimRadios].asInt() | flag; - } else { - (*dictionary_)[kNetsimRadios] = flag; - } -} - -bool CuttlefishConfig::netsim_radio_enabled(NetsimRadio flag) const { - return (*dictionary_)[kNetsimRadios].asInt() & flag; -} - static constexpr char kNetsimInstanceNum[] = "netsim_instance_num"; int CuttlefishConfig::netsim_instance_num() const { return (*dictionary_)[kNetsimInstanceNum].asInt(); diff --git a/base/cvd/cuttlefish/host/libs/config/cuttlefish_config.h b/base/cvd/cuttlefish/host/libs/config/cuttlefish_config.h index 0a667ab4473..4c40c4c788d 100644 --- a/base/cvd/cuttlefish/host/libs/config/cuttlefish_config.h +++ b/base/cvd/cuttlefish/host/libs/config/cuttlefish_config.h @@ -155,16 +155,6 @@ class CuttlefishConfig { void set_casimir_rf_port(int port); int casimir_rf_port() const; - // Flags for the set of radios that are connected to netsim - enum NetsimRadio { - Bluetooth = 0b00000001, - Wifi = 0b00000010, - Uwb = 0b00000100, - Nfc = 0b00001000, - }; - - void netsim_radio_enable(NetsimRadio flag); - bool netsim_radio_enabled(NetsimRadio flag) const; void set_netsim_instance_num(int netsim_instance_num); int netsim_instance_num() const; // Netsim has a built-in connector to forward packets to another daemon based @@ -512,6 +502,7 @@ class CuttlefishConfig { // Configuration flags for a minimal device bool enable_minimal_mode() const; bool enable_modem_simulator() const; + bool enable_modem_netsim() const; int modem_simulator_instance_number() const; int modem_simulator_sim_type() const; @@ -747,6 +738,7 @@ class CuttlefishConfig { // Configuration flags for a minimal device void set_enable_minimal_mode(bool enable_minimal_mode); void set_enable_modem_simulator(bool enable_modem_simulator); + void set_enable_modem_netsim(bool enable); void set_modem_simulator_instance_number(int instance_numbers); void set_modem_simulator_sim_type(int sim_type); diff --git a/base/cvd/cuttlefish/host/libs/config/cuttlefish_config_instance.cpp b/base/cvd/cuttlefish/host/libs/config/cuttlefish_config_instance.cpp index 83d7dda6cb0..337a9ac0f6b 100644 --- a/base/cvd/cuttlefish/host/libs/config/cuttlefish_config_instance.cpp +++ b/base/cvd/cuttlefish/host/libs/config/cuttlefish_config_instance.cpp @@ -1351,6 +1351,15 @@ void CuttlefishConfig::MutableInstanceSpecific::set_modem_simulator_ports( (*Dictionary())[kModemSimulatorPorts] = modem_simulator_ports; } +static constexpr char kEnableModemNetsim[] = "enable_modem_netsim"; +bool CuttlefishConfig::InstanceSpecific::enable_modem_netsim() const { + return (*Dictionary())[kEnableModemNetsim].asBool(); +} +void CuttlefishConfig::MutableInstanceSpecific::set_enable_modem_netsim( + bool enable) { + (*Dictionary())[kEnableModemNetsim] = enable; +} + std::string CuttlefishConfig::InstanceSpecific::launcher_log_path() const { return AbsolutePath(PerInstanceLogPath(kLogNameLauncher)); } From 7e37f4c8febc689bea395db43735d21fef4a5175 Mon Sep 17 00:00:00 2001 From: Bailey Kuo Date: Tue, 4 Aug 2026 04:44:21 +0000 Subject: [PATCH 29/53] cuttlefish: Wire up Netsim UDS socket (--grpc_uds_path) Exposes `EnableNetsimNfc()` instead of netsim_radio_enabled to simplify netsim nfc checking, avoiding passing --grpc_uds_path unconditionally. Bug: 525044943 Test: bazel build //base/cvd/cuttlefish/... TAG=agy CONV=97998051-73aa-44c8-83ac-51de8d5fd83d --- .../host/commands/run_cvd/launch/BUILD.bazel | 1 + .../commands/run_cvd/launch/netsim_server.cpp | 17 +++++++++++++---- .../commands/run_cvd/launch/netsim_server.h | 4 +++- .../host/libs/config/cuttlefish_config.cpp | 4 ++++ .../host/libs/config/cuttlefish_config.h | 2 ++ 5 files changed, 23 insertions(+), 5 deletions(-) diff --git a/base/cvd/cuttlefish/host/commands/run_cvd/launch/BUILD.bazel b/base/cvd/cuttlefish/host/commands/run_cvd/launch/BUILD.bazel index 6d9b30f27f1..d86c9eed9a3 100644 --- a/base/cvd/cuttlefish/host/commands/run_cvd/launch/BUILD.bazel +++ b/base/cvd/cuttlefish/host/commands/run_cvd/launch/BUILD.bazel @@ -281,6 +281,7 @@ cf_cc_library( "//cuttlefish/common/libs/fs", "//cuttlefish/common/libs/utils:files", "//cuttlefish/common/libs/utils:subprocess", + "//cuttlefish/host/commands/run_cvd/launch:grpc_socket_creator", "//cuttlefish/host/libs/config:config_utils", "//cuttlefish/host/libs/config:cuttlefish_config", "//cuttlefish/host/libs/config:known_paths", diff --git a/base/cvd/cuttlefish/host/commands/run_cvd/launch/netsim_server.cpp b/base/cvd/cuttlefish/host/commands/run_cvd/launch/netsim_server.cpp index 9893456d50f..f795baa25f0 100644 --- a/base/cvd/cuttlefish/host/commands/run_cvd/launch/netsim_server.cpp +++ b/base/cvd/cuttlefish/host/commands/run_cvd/launch/netsim_server.cpp @@ -32,6 +32,7 @@ #include "cuttlefish/common/libs/fs/shared_fd.h" #include "cuttlefish/common/libs/utils/files.h" #include "cuttlefish/common/libs/utils/subprocess.h" +#include "cuttlefish/host/commands/run_cvd/launch/grpc_socket_creator.h" #include "cuttlefish/host/libs/config/config_utils.h" #include "cuttlefish/host/libs/config/cuttlefish_config.h" #include "cuttlefish/host/libs/config/known_paths.h" @@ -110,8 +111,9 @@ class Device { class NetsimServer : public CommandSource { public: INJECT(NetsimServer(const CuttlefishConfig& config, - const CuttlefishConfig::InstanceSpecific& instance)) - : config_(config), instance_(instance) {} + const CuttlefishConfig::InstanceSpecific& instance, + GrpcSocketCreator& grpc_socket)) + : config_(config), instance_(instance), grpc_socket_(grpc_socket) {} // CommandSource Result> Commands() override { @@ -123,6 +125,11 @@ class NetsimServer : public CommandSource { // Port configuration. netsimd.AddParameter("--hci_port=", config_.rootcanal_hci_port()); + if (EnableNetsimNfc(config_)) { + netsimd.AddParameter("--grpc_uds_path=", grpc_socket_.CreateGrpcSocket( + "NetsimControlServer")); + } + // When no connector is requested, add the instance number if (config_.netsim_connector_instance_num() == config_.netsim_instance_num()) { @@ -223,7 +230,7 @@ class NetsimServer : public CommandSource { device.chips.emplace_back(chip); } // Add nfc chip if enabled - if (config_.enable_host_nfc() && !config_.enable_host_nfc_connector()) { + if (EnableNetsimNfc(config_)) { Chip chip("NFC"); chip.fd_in = CF_EXPECT(MakeFifo(instance, "nfc_fifo_vm.in")); chip.fd_out = CF_EXPECT(MakeFifo(instance, "nfc_fifo_vm.out")); @@ -277,12 +284,14 @@ class NetsimServer : public CommandSource { std::vector devices_; const CuttlefishConfig& config_; const CuttlefishConfig::InstanceSpecific instance_; + GrpcSocketCreator& grpc_socket_; }; } // namespace fruit::Component> + const CuttlefishConfig::InstanceSpecific, + GrpcSocketCreator>> NetsimServerComponent() { return fruit::createComponent() .addMultibinding() diff --git a/base/cvd/cuttlefish/host/commands/run_cvd/launch/netsim_server.h b/base/cvd/cuttlefish/host/commands/run_cvd/launch/netsim_server.h index 65c0640ffcd..9dcf3e4a54b 100644 --- a/base/cvd/cuttlefish/host/commands/run_cvd/launch/netsim_server.h +++ b/base/cvd/cuttlefish/host/commands/run_cvd/launch/netsim_server.h @@ -17,12 +17,14 @@ #include "fruit/fruit.h" +#include "cuttlefish/host/commands/run_cvd/launch/grpc_socket_creator.h" #include "cuttlefish/host/libs/config/cuttlefish_config.h" namespace cuttlefish { fruit::Component> + const CuttlefishConfig::InstanceSpecific, + GrpcSocketCreator>> NetsimServerComponent(); } // namespace cuttlefish diff --git a/base/cvd/cuttlefish/host/libs/config/cuttlefish_config.cpp b/base/cvd/cuttlefish/host/libs/config/cuttlefish_config.cpp index b4b02251775..cb868aff4e4 100644 --- a/base/cvd/cuttlefish/host/libs/config/cuttlefish_config.cpp +++ b/base/cvd/cuttlefish/host/libs/config/cuttlefish_config.cpp @@ -692,6 +692,10 @@ std::vector CuttlefishConfig::environment_dirs() const { return result; } +bool EnableNetsimNfc(const CuttlefishConfig& config) { + return config.enable_host_nfc() && !config.enable_host_nfc_connector(); +} + bool VmManagerIsCrosvm(const CuttlefishConfig& config) { return VmManagerIsCrosvm(config.vm_manager()); } diff --git a/base/cvd/cuttlefish/host/libs/config/cuttlefish_config.h b/base/cvd/cuttlefish/host/libs/config/cuttlefish_config.h index 4c40c4c788d..6690f31c99b 100644 --- a/base/cvd/cuttlefish/host/libs/config/cuttlefish_config.h +++ b/base/cvd/cuttlefish/host/libs/config/cuttlefish_config.h @@ -932,4 +932,6 @@ bool VmManagerIsCrosvm(const CuttlefishConfig&); bool VmManagerIsQemu(const CuttlefishConfig&); bool VmManagerIsGem5(const CuttlefishConfig&); +bool EnableNetsimNfc(const CuttlefishConfig& config); + } // namespace cuttlefish From ae587e1bd285d5b79e87072736fa5f9f553e7a3b Mon Sep 17 00:00:00 2001 From: Ram Muthiah Date: Tue, 4 Aug 2026 14:13:28 -0700 Subject: [PATCH 30/53] feat(cvd): Inject NETSIM_GRPC_PORT as environment variable into netsimd TAG=agy CONV=7e6b7c86-e570-4900-a8f4-683776c7dc60 Assisted-by: Jetski:GeminiNext --- .../host/commands/run_cvd/launch/netsim_server.cpp | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/base/cvd/cuttlefish/host/commands/run_cvd/launch/netsim_server.cpp b/base/cvd/cuttlefish/host/commands/run_cvd/launch/netsim_server.cpp index f795baa25f0..43af27e9587 100644 --- a/base/cvd/cuttlefish/host/commands/run_cvd/launch/netsim_server.cpp +++ b/base/cvd/cuttlefish/host/commands/run_cvd/launch/netsim_server.cpp @@ -145,8 +145,16 @@ class NetsimServer : public CommandSource { } // Add parameters from passthrough option --netsim-args. - for (auto const& arg : config_.netsim_args()) { - netsimd.AddParameter(arg); + // NETSIM_GRPC_PORT is extracted and injected as an environment variable; + // all other options are passed as command-line arguments. + for (const std::string& arg : config_.netsim_args()) { + if (arg.starts_with("NETSIM_GRPC_PORT=")) { + const std::string::size_type equals_pos = arg.find('='); + netsimd.AddEnvironmentVariable(arg.substr(0, equals_pos), + arg.substr(equals_pos + 1)); + } else { + netsimd.AddParameter(arg); + } } // Add command for forwarding the HCI port to a vsock server. From 8f54b82ed9bd76d71e01167a4fa7771447e5f82a Mon Sep 17 00:00:00 2001 From: Ram Muthiah Date: Fri, 24 Jul 2026 17:16:34 +0000 Subject: [PATCH 31/53] Fix frontend host_orchestrator BUILD.bazel file references Remove deleted Go source files (fetchartifactsaction.go, createcvdaction_test.go, instancemanager_test.go) and unused dependencies from frontend/src/host_orchestrator/orchestrator/BUILD.bazel. Bug: b/519240653 --- frontend/src/host_orchestrator/orchestrator/BUILD.bazel | 4 ---- 1 file changed, 4 deletions(-) diff --git a/frontend/src/host_orchestrator/orchestrator/BUILD.bazel b/frontend/src/host_orchestrator/orchestrator/BUILD.bazel index 40e16b69a9f..7fb7dfcdfe1 100644 --- a/frontend/src/host_orchestrator/orchestrator/BUILD.bazel +++ b/frontend/src/host_orchestrator/orchestrator/BUILD.bazel @@ -12,7 +12,6 @@ go_library( "displayremoveaction.go", "displayscreenshotaction.go", "execcvdcommandaction.go", - "fetchartifactsaction.go", "getscreenrecordingaction.go", "imagedirectories.go", "instancemanager.go", @@ -43,9 +42,7 @@ go_test( name = "orchestrator_test", srcs = [ "controller_test.go", - "createcvdaction_test.go", "imagedirectories_test.go", - "instancemanager_test.go", "listcvdsaction_test.go", "operation_test.go", "userartifacts_test.go", @@ -56,7 +53,6 @@ go_test( "//src/host_orchestrator/api/v1:api", "//src/host_orchestrator/orchestrator/debug", "//src/host_orchestrator/orchestrator/testing", - "//src/liboperator/operator", "@com_github_google_btree//:btree", "@com_github_google_go_cmp//cmp", "@com_github_gorilla_mux//:mux", From f99579b8b3813ed3a446ab50c8d943aa0cb94000 Mon Sep 17 00:00:00 2001 From: Cameron Beeley Date: Thu, 13 Aug 2026 03:48:19 +0000 Subject: [PATCH 32/53] host_orchestrator: reject archive entries that escape the extraction dir The user-artifacts extractor (ExtractArtifact -> untar/unzip) joined attacker-controlled archive entry names onto the destination directory with no containment check and created symlink entries verbatim, allowing a crafted .tar.gz/.zip to write files outside the extraction directory Add isSafeToExtract() and use it in untar and unzip to verify each entry's resolved path stays within the destination, and reuse it to reject symlink entries whose resolved target escapes it. Add regression tests for the tar-traversal, tar-symlink and zip-traversal vectors. --- .../orchestrator/userartifacts.go | 23 +- .../orchestrator/userartifacts_test.go | 218 ++++++++++-------- 2 files changed, 141 insertions(+), 100 deletions(-) diff --git a/frontend/src/host_orchestrator/orchestrator/userartifacts.go b/frontend/src/host_orchestrator/orchestrator/userartifacts.go index 20611b87d90..6d791445f1b 100644 --- a/frontend/src/host_orchestrator/orchestrator/userartifacts.go +++ b/frontend/src/host_orchestrator/orchestrator/userartifacts.go @@ -312,6 +312,13 @@ func extractFile(dst string, src string) error { return nil } +// isSafeToExtract reports whether target (already joined onto dst) stays within +// dst, rejecting paths that escape via ".." components or an absolute path +func isSafeToExtract(dst string, target string) bool { + rel, err := filepath.Rel(dst, target) + return err == nil && rel != ".." && !strings.HasPrefix(rel, ".."+string(os.PathSeparator)) +} + func untar(dst string, src string) error { r, err := os.Open(src) if err != nil { @@ -336,6 +343,9 @@ func untar(dst string, src string) error { continue } target := filepath.Join(dst, header.Name) + if !isSafeToExtract(dst, target) { + return fmt.Errorf("archive entry %q escapes the extraction directory", header.Name) + } switch header.Typeflag { case tar.TypeDir: if _, err := os.Stat(target); err != nil { @@ -356,6 +366,13 @@ func untar(dst string, src string) error { } f.Close() case tar.TypeSymlink: + linkTarget := header.Linkname + if !filepath.IsAbs(linkTarget) { + linkTarget = filepath.Join(filepath.Dir(target), linkTarget) + } + if !isSafeToExtract(dst, linkTarget) { + return fmt.Errorf("symlink entry %q targets outside the extraction directory", header.Name) + } if err := os.Symlink(header.Linkname, target); err != nil { return err } @@ -391,7 +408,11 @@ func unzip(dstDir string, src string) error { if f.Mode().IsDir() { continue } - if err := extractTo(filepath.Join(dstDir, f.Name), f); err != nil { + target := filepath.Join(dstDir, f.Name) + if !isSafeToExtract(dstDir, target) { + return fmt.Errorf("archive entry %q escapes the extraction directory", f.Name) + } + if err := extractTo(target, f); err != nil { return err } } diff --git a/frontend/src/host_orchestrator/orchestrator/userartifacts_test.go b/frontend/src/host_orchestrator/orchestrator/userartifacts_test.go index e9e82bf8896..2fa26154abf 100644 --- a/frontend/src/host_orchestrator/orchestrator/userartifacts_test.go +++ b/frontend/src/host_orchestrator/orchestrator/userartifacts_test.go @@ -238,45 +238,24 @@ func TestStatArtifactSucceeds(t *testing.T) { } func TestExtractArtifactSucceedsWithZipFormat(t *testing.T) { - rootDir := orchtesting.TempDir(t) - defer orchtesting.RemoveDir(t, rootDir) - opts := UserArtifactsManagerOpts{RootDir: rootDir} - uam, err := NewUserArtifactsManagerImpl(opts) - if err != nil { - t.Fatal(err) - } + tempDir := orchtesting.TempDir(t) + defer orchtesting.RemoveDir(t, tempDir) zipContents := map[string]string{ "alpha.txt": "This is alpha.\n", "bravo.txt": "This is bravo.\n", "charlie.txt": "This is charlie.\n", "delta.txt": "This is delta.\n", } - tempDir := orchtesting.TempDir(t) - defer orchtesting.RemoveDir(t, tempDir) zipFile, err := createZip(tempDir, zipContents) if err != nil { t.Fatal(err) } - data, err := ioutil.ReadFile(zipFile) - if err != nil { - t.Fatal(err) - } - checksum := getSha256Sum(data) - chunk := UserArtifactChunk{ - Name: filepath.Base(zipFile), - OffsetBytes: 0, - SizeBytes: int64(len(data)), - FileSizeBytes: int64(len(data)), - File: bytes.NewReader(data), - } - if err := uam.UpdateArtifact(checksum, chunk); err != nil { - t.Fatal(err) - } - if err := uam.ExtractArtifact(checksum); err != nil { + extractedDir, err := updateAndExtractArtifact(t, zipFile) + if err != nil { t.Fatal(err) } - if got, err := getContents(filepath.Join(rootDir, fmt.Sprintf("%s_extracted", checksum))); err != nil { + if got, err := getContents(extractedDir); err != nil { t.Fatal(err) } else if diff := cmp.Diff(zipContents, got); diff != "" { t.Fatalf("content mismatch (-want +got):\n%s", diff) @@ -284,77 +263,65 @@ func TestExtractArtifactSucceedsWithZipFormat(t *testing.T) { } func TestExtractArtifactSucceedsWithTarGzFormat(t *testing.T) { - rootDir := orchtesting.TempDir(t) - defer orchtesting.RemoveDir(t, rootDir) - opts := UserArtifactsManagerOpts{RootDir: rootDir} - uam, err := NewUserArtifactsManagerImpl(opts) - if err != nil { - t.Fatal(err) - } - tarContents := map[string]string{ - "foo/alpha.txt": "This is alpha.\n", - "foo/bravo.txt": "This is bravo.\n", - "bar/charlie.txt": "This is charlie.\n", - "delta.txt": "This is delta.\n", - } tempDir := orchtesting.TempDir(t) defer orchtesting.RemoveDir(t, tempDir) + tarContents := map[string]archiveEntry{ + "foo/alpha.txt": {Content: "This is alpha.\n"}, + "foo/bravo.txt": {Content: "This is bravo.\n"}, + "bar/charlie.txt": {Content: "This is charlie.\n"}, + "delta.txt": {Content: "This is delta.\n"}, + } tarFile, err := createTarGz(tempDir, tarContents) if err != nil { t.Fatal(err) } - data, err := ioutil.ReadFile(tarFile) + + extractedDir, err := updateAndExtractArtifact(t, tarFile) if err != nil { t.Fatal(err) } - checksum := getSha256Sum(data) - chunk := UserArtifactChunk{ - Name: filepath.Base(tarFile), - OffsetBytes: 0, - SizeBytes: int64(len(data)), - FileSizeBytes: int64(len(data)), - File: bytes.NewReader(data), + tarWant := map[string]string{} + for name, entry := range tarContents { + tarWant[name] = entry.Content } - if err := uam.UpdateArtifact(checksum, chunk); err != nil { + if got, err := getContents(extractedDir); err != nil { t.Fatal(err) + } else if diff := cmp.Diff(tarWant, got); diff != "" { + t.Fatalf("content mismatch (-want +got):\n%s", diff) } +} - if err := uam.ExtractArtifact(checksum); err != nil { +func TestExtractArtifactFailsWithInvalidFileFormat(t *testing.T) { + tempDir := orchtesting.TempDir(t) + defer orchtesting.RemoveDir(t, tempDir) + archive := filepath.Join(tempDir, testFileName) + if err := ioutil.WriteFile(archive, []byte(testFileData), 0644); err != nil { t.Fatal(err) } - if got, err := getContents(filepath.Join(rootDir, fmt.Sprintf("%s_extracted", checksum))); err != nil { - t.Fatal(err) - } else if diff := cmp.Diff(tarContents, got); diff != "" { - t.Fatalf("content mismatch (-want +got):\n%s", diff) + if _, err := updateAndExtractArtifact(t, archive); err == nil { + t.Fatal("Expected an error") } } -func TestExtractArtifactFailsWithInvalidFileFormat(t *testing.T) { - rootDir := orchtesting.TempDir(t) - defer orchtesting.RemoveDir(t, rootDir) - opts := UserArtifactsManagerOpts{RootDir: rootDir} - uam, err := NewUserArtifactsManagerImpl(opts) +func TestExtractArtifactAfterArtifactIsFullyExtractedFails(t *testing.T) { + tempDir := orchtesting.TempDir(t) + defer orchtesting.RemoveDir(t, tempDir) + archive, err := createTarGz(tempDir, map[string]archiveEntry{"file": {Content: "content\n"}}) if err != nil { t.Fatal(err) } - checksum := getSha256Sum([]byte(testFileData)) - chunk := UserArtifactChunk{ - Name: testFileName, - OffsetBytes: 0, - SizeBytes: int64(len(testFileData)), - FileSizeBytes: int64(len(testFileData)), - File: strings.NewReader(testFileData), - } - if err := uam.UpdateArtifact(checksum, chunk); err != nil { + // Extract twice on the same manager: the first extraction must succeed and + // the second must fail because the artifact is already extracted. + uam, checksum := updateArtifact(t, archive) + if err := uam.ExtractArtifact(checksum); err != nil { t.Fatal(err) } - if err := uam.ExtractArtifact(checksum); err == nil { t.Fatal("Expected an error") } } -func TestExtractArtifactAfterArtifactIsFullyExtractedFails(t *testing.T) { +func TestExtractArtifactFailsArtifactNotFound(t *testing.T) { rootDir := orchtesting.TempDir(t) defer orchtesting.RemoveDir(t, rootDir) opts := UserArtifactsManagerOpts{RootDir: rootDir} @@ -362,46 +329,44 @@ func TestExtractArtifactAfterArtifactIsFullyExtractedFails(t *testing.T) { if err != nil { t.Fatal(err) } + + if err := uam.ExtractArtifact("foo"); err == nil { + t.Fatal("Expected an error") + } +} + +func TestExtractArtifactFailsWithTarPathTraversal(t *testing.T) { tempDir := orchtesting.TempDir(t) defer orchtesting.RemoveDir(t, tempDir) - archive, err := createTarGz(tempDir, map[string]string{"file": "content\n"}) + archive, err := createTarGz(tempDir, map[string]archiveEntry{"../../../../../../PWNED": {Content: "owned"}}) if err != nil { t.Fatal(err) } - data, err := ioutil.ReadFile(archive) - if err != nil { - t.Fatal(err) - } - checksum := getSha256Sum(data) - chunk := UserArtifactChunk{ - Name: filepath.Base(archive), - OffsetBytes: 0, - SizeBytes: int64(len(data)), - FileSizeBytes: int64(len(data)), - File: bytes.NewReader(data), - } - if err := uam.UpdateArtifact(checksum, chunk); err != nil { - t.Fatal(err) + if _, err := updateAndExtractArtifact(t, archive); err == nil { + t.Fatal("Expected an error") } - if err := uam.ExtractArtifact(checksum); err != nil { +} + +func TestExtractArtifactFailsWithZipPathTraversal(t *testing.T) { + tempDir := orchtesting.TempDir(t) + defer orchtesting.RemoveDir(t, tempDir) + archive, err := createZip(tempDir, map[string]string{"../../../../../../PWNED": "owned"}) + if err != nil { t.Fatal(err) } - - if err := uam.ExtractArtifact(checksum); err == nil { + if _, err := updateAndExtractArtifact(t, archive); err == nil { t.Fatal("Expected an error") } } -func TestExtractArtifactFailsArtifactNotFound(t *testing.T) { - rootDir := orchtesting.TempDir(t) - defer orchtesting.RemoveDir(t, rootDir) - opts := UserArtifactsManagerOpts{RootDir: rootDir} - uam, err := NewUserArtifactsManagerImpl(opts) +func TestExtractArtifactFailsWithTarSymlinkEscape(t *testing.T) { + tempDir := orchtesting.TempDir(t) + defer orchtesting.RemoveDir(t, tempDir) + archive, err := createTarGz(tempDir, map[string]archiveEntry{"sneak": {Symlink: "../../../../../../etc"}}) if err != nil { t.Fatal(err) } - - if err := uam.ExtractArtifact("foo"); err == nil { + if _, err := updateAndExtractArtifact(t, archive); err == nil { t.Fatal("Expected an error") } } @@ -650,7 +615,15 @@ func getSubdirs(path string) []string { return subdirs } -func createTarGz(dir string, contents map[string]string) (string, error) { +// archiveEntry describes an entry to add to an archive built by createTarGz: a +// regular file holding Content, or, when Symlink is non-empty, a symbolic link +// pointing at Symlink (used to exercise the symlink-escape guard). +type archiveEntry struct { + Content string + Symlink string +} + +func createTarGz(dir string, contents map[string]archiveEntry) (string, error) { tarFile, err := ioutil.TempFile(dir, "*.tar.gz") if err != nil { return "", err @@ -665,7 +638,19 @@ func createTarGz(dir string, contents map[string]string) (string, error) { directories := map[string]struct{}{} - for name, content := range contents { + for name, entry := range contents { + if entry.Symlink != "" { + header := tar.Header{ + Name: name, + Typeflag: tar.TypeSymlink, + Linkname: entry.Symlink, + Mode: 0777, + } + if err := tarWriter.WriteHeader(&header); err != nil { + return "", err + } + continue + } dir, _ := filepath.Split(name) dirPaths := getSubdirs(dir) for _, dp := range dirPaths { @@ -684,15 +669,15 @@ func createTarGz(dir string, contents map[string]string) (string, error) { } header := tar.Header{ Name: name, - Size: int64(len(content)), + Size: int64(len(entry.Content)), Mode: 0555, } if err := tarWriter.WriteHeader(&header); err != nil { return "", err } - if n, err := tarWriter.Write([]byte(content)); err != nil { + if n, err := tarWriter.Write([]byte(entry.Content)); err != nil { return "", err - } else if n != len(content) { + } else if n != len(entry.Content) { return "", fmt.Errorf("Failed to write entire file: %s", name) } } @@ -707,3 +692,38 @@ func getChunkStateItemList(cs *chunkState) []chunkStateItem { }) return items } + +// updateArtifact uploads the archive at archivePath as a single chunk, returning +// the manager and the artifact checksum so callers can extract it. +func updateArtifact(t *testing.T, archivePath string) (*UserArtifactsManagerImpl, string) { + rootDir := orchtesting.TempDir(t) + t.Cleanup(func() { orchtesting.RemoveDir(t, rootDir) }) + uam, err := NewUserArtifactsManagerImpl(UserArtifactsManagerOpts{RootDir: rootDir}) + if err != nil { + t.Fatal(err) + } + data, err := ioutil.ReadFile(archivePath) + if err != nil { + t.Fatal(err) + } + checksum := getSha256Sum(data) + chunk := UserArtifactChunk{ + Name: filepath.Base(archivePath), + OffsetBytes: 0, + SizeBytes: int64(len(data)), + FileSizeBytes: int64(len(data)), + File: bytes.NewReader(data), + } + if err := uam.UpdateArtifact(checksum, chunk); err != nil { + t.Fatal(err) + } + return uam, checksum +} + +// updateAndExtractArtifact uploads the archive at archivePath as a single chunk and +// extracts it, returning the directory the artifact was extracted into so +// callers can inspect the result. +func updateAndExtractArtifact(t *testing.T, archivePath string) (string, error) { + uam, checksum := updateArtifact(t, archivePath) + return uam.ExtractedArtifactPath(checksum), uam.ExtractArtifact(checksum) +} From 095b3d86f34393648eb80a7f2b86e5f186c06a6b Mon Sep 17 00:00:00 2001 From: Ram Muthiah Date: Mon, 29 Jun 2026 12:01:46 -0700 Subject: [PATCH 33/53] Update off Node 20 There's a warning that Node 20 is being deprecated. To quiet it, apply the minimal update to the dep that's pulling in Node 20. In this case - that's github actions on v7. Just bumped it to v8 which updates to Node 24 under the hood. --- .github/workflows/gemini-dispatch.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/gemini-dispatch.yml b/.github/workflows/gemini-dispatch.yml index 5d6cce49646..5f10a5d25c7 100644 --- a/.github/workflows/gemini-dispatch.yml +++ b/.github/workflows/gemini-dispatch.yml @@ -69,7 +69,7 @@ jobs: - name: 'Extract command' id: 'extract_command' - uses: 'actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea' # ratchet:actions/github-script@v7 + uses: 'actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd' # ratchet:actions/github-script@v8 env: EVENT_TYPE: '${{ github.event_name }}.${{ github.event.action }}' REQUEST: '${{ github.event.comment.body || github.event.review.body || github.event.issue.body }}' From fe3aaa242d1172e563a221b0651717b8c8759d54 Mon Sep 17 00:00:00 2001 From: Sergio Andres Rodriguez Orama Date: Fri, 31 Jul 2026 16:26:57 -0400 Subject: [PATCH 34/53] cvd: Update --media flag format to [type]:[key=value] Modify --media flag parsing logic to support the new pattern: "--media=[type]:[key1]=[val1]:[key2]=[val2]" e.g. "--media=v4l2_emulated_camera_mplane:lens_facing=BACK" This clearly separates the primary media type from its optional properties using `:`. Bug: b/541325033 Assisted-by: Jetski:Gemini 3.5 Flash --- .../cvd/cli/parser/flags_parser_test.cc | 8 ++-- .../cli/parser/instance/cf_media_configs.cpp | 8 ++-- .../cvd/cuttlefish/host/libs/config/media.cpp | 37 ++++++++++--------- base/cvd/cuttlefish/host/libs/config/media.h | 15 +++++--- e2etests/cvd/media_tests/main_test.go | 2 +- 5 files changed, 37 insertions(+), 33 deletions(-) diff --git a/base/cvd/cuttlefish/host/commands/cvd/cli/parser/flags_parser_test.cc b/base/cvd/cuttlefish/host/commands/cvd/cli/parser/flags_parser_test.cc index b0ca0d1c7b8..bc41537b144 100644 --- a/base/cvd/cuttlefish/host/commands/cvd/cli/parser/flags_parser_test.cc +++ b/base/cvd/cuttlefish/host/commands/cvd/cli/parser/flags_parser_test.cc @@ -374,7 +374,7 @@ TEST(FlagsParserTest, ParseMediaSplaneSingleInstance) { << "Invalid Json string"; auto serialized_data = LaunchCvdParserTester(json_configs); EXPECT_TRUE(serialized_data.ok()) << serialized_data.error().Trace(); - EXPECT_TRUE(FindConfig(*serialized_data, "--media=type=v4l2_emulated_camera_splane")) + EXPECT_TRUE(FindConfig(*serialized_data, "--media=v4l2_emulated_camera_splane")) << "media flag is missing or wrongly formatted"; } @@ -407,7 +407,7 @@ TEST(FlagsParserTest, ParseMediaSplaneTwoDevices) { auto serialized_data = LaunchCvdParserTester(json_configs); EXPECT_TRUE(serialized_data.ok()) << serialized_data.error().Trace(); EXPECT_EQ(std::count(serialized_data->begin(), serialized_data->end(), - "--media=type=v4l2_emulated_camera_splane"), + "--media=v4l2_emulated_camera_splane"), 2); } @@ -437,7 +437,7 @@ TEST(FlagsParserTest, ParseMediaMplane) { auto serialized_data = LaunchCvdParserTester(json_configs); EXPECT_TRUE(serialized_data.ok()) << serialized_data.error().Trace(); - EXPECT_TRUE(FindConfig(*serialized_data, "--media=type=v4l2_emulated_camera_mplane")) + EXPECT_TRUE(FindConfig(*serialized_data, "--media=v4l2_emulated_camera_mplane")) << "media flag is missing or wrongly formatted"; } @@ -469,7 +469,7 @@ TEST(FlagsParserTest, ParseMediaV4l2Proxy) { auto serialized_data = LaunchCvdParserTester(json_configs); EXPECT_TRUE(serialized_data.ok()) << serialized_data.error().Trace(); - EXPECT_TRUE(FindConfig(*serialized_data, "--media=type=v4l2_proxy")) + EXPECT_TRUE(FindConfig(*serialized_data, "--media=v4l2_proxy")) << "media flag is missing or wrongly formatted"; } diff --git a/base/cvd/cuttlefish/host/commands/cvd/cli/parser/instance/cf_media_configs.cpp b/base/cvd/cuttlefish/host/commands/cvd/cli/parser/instance/cf_media_configs.cpp index 94e6994d597..71b99a0fd20 100644 --- a/base/cvd/cuttlefish/host/commands/cvd/cli/parser/instance/cf_media_configs.cpp +++ b/base/cvd/cuttlefish/host/commands/cvd/cli/parser/instance/cf_media_configs.cpp @@ -41,16 +41,16 @@ Result> GenerateMediaFlags( for (const auto& device : instance.media().devices()) { std::string flag = "--media="; if (device.has_v4l2_emulated_camera_splane()) { - flag += "type=v4l2_emulated_camera_splane"; + flag += "v4l2_emulated_camera_splane"; } else if (device.has_v4l2_emulated_camera_mplane()) { - flag += "type=v4l2_emulated_camera_mplane"; + flag += "v4l2_emulated_camera_mplane"; } else if (device.has_v4l2_proxy()) { // TODO(b/520114678): Use device.v4l2_proxy.device_path when // supported. - flag += "type=v4l2_proxy"; + flag += "v4l2_proxy"; } if (device.has_lens_facing()) { - flag += ",lens_facing=" + device.lens_facing(); + flag += ":lens_facing=" + device.lens_facing(); } flags.push_back(flag); } diff --git a/base/cvd/cuttlefish/host/libs/config/media.cpp b/base/cvd/cuttlefish/host/libs/config/media.cpp index 7adbadaf61c..5ac4103b2e8 100644 --- a/base/cvd/cuttlefish/host/libs/config/media.cpp +++ b/base/cvd/cuttlefish/host/libs/config/media.cpp @@ -16,6 +16,7 @@ #include "cuttlefish/host/libs/config/media.h" +#include #include #include #include @@ -38,30 +39,30 @@ static constexpr char kMediaTypeV4l2Proxy[] = "v4l2_proxy"; Result> ParseMediaConfig( const std::string& flag) { - std::unordered_map props; - if (!flag.empty()) { - const std::vector pairs = absl::StrSplit(flag, ","); - for (const std::string& pair : pairs) { - const std::vector keyvalue = absl::StrSplit(pair, "="); - CF_EXPECT_EQ(keyvalue.size(), 2, - "Invalid media flag key-value: \"" << flag << "\""); - const std::string& prop_key = keyvalue[0]; - const std::string& prop_val = keyvalue[1]; - props[prop_key] = prop_val; - } - } + const std::vector parts = absl::StrSplit(flag, ":"); + CF_EXPECT(!parts.empty(), "Invalid media flag: \"" << flag << "\""); - auto type_it = props.find("type"); - CF_EXPECT(type_it != props.end(), "Missing media type"); + const std::string& type_str = parts[0]; CuttlefishConfig::MediaType type{CuttlefishConfig::MediaType::kUnknown}; - if (type_it->second == kMediaTypeV4l2EmulatedCameraSPlane) { + if (type_str == kMediaTypeV4l2EmulatedCameraSPlane) { type = CuttlefishConfig::MediaType::kV4l2EmulatedCameraSPlane; - } else if (type_it->second == kMediaTypeV4l2EmulatedCameraMPlane) { + } else if (type_str == kMediaTypeV4l2EmulatedCameraMPlane) { type = CuttlefishConfig::MediaType::kV4l2EmulatedCameraMPlane; - } else if (type_it->second == kMediaTypeV4l2Proxy) { + } else if (type_str == kMediaTypeV4l2Proxy) { type = CuttlefishConfig::MediaType::kV4l2Proxy; } else { - return CF_ERRF("Unknown media type value: \"{}\"", type_it->second); + return CF_ERRF("Unknown media type value: \"{}\"", type_str); + } + + std::unordered_map props; + for (size_t i = 1; i < parts.size(); ++i) { + const std::vector keyvalue = absl::StrSplit(parts[i], "="); + CF_EXPECT_EQ(keyvalue.size(), 2, + "Invalid media flag key-value: \"" << parts[i] << "\" in \"" + << flag << "\""); + const std::string& prop_key = keyvalue[0]; + const std::string& prop_val = keyvalue[1]; + props[prop_key] = prop_val; } std::string lens_facing = ""; diff --git a/base/cvd/cuttlefish/host/libs/config/media.h b/base/cvd/cuttlefish/host/libs/config/media.h index 946cebf64fc..fd329ce2021 100644 --- a/base/cvd/cuttlefish/host/libs/config/media.h +++ b/base/cvd/cuttlefish/host/libs/config/media.h @@ -24,15 +24,18 @@ namespace cuttlefish { constexpr const char kMediaFlag[] = "media"; constexpr const char kMediaHelp[] = - "Comma separated key=value pairs of media device properties. Supported " - "properties:\n" - " 'type': optional, defaults to 'v4l2_emulated_camera_splane', supported values:\n" - " 'v4l2_emulated_camera_splane': emulated media capture device (single-plane)\n" - " 'v4l2_emulated_camera_mplane': emulated media capture device (multi-plane)\n" + "Colon separated media device properties: " + "\"[type]:[key1]=[val1]:[key2]=[val2]\". " + "Supported types:\n" + " 'v4l2_emulated_camera_splane': emulated media capture device " + "(single-plane)\n" + " 'v4l2_emulated_camera_mplane': emulated media capture device " + "(multi-plane)\n" " 'v4l2_proxy': proxy a host V4L2 device into the guest\n" + "Supported keys:\n" " 'lens_facing': optional, supported values: 'FRONT', 'BACK', 'EXTERNAL'\n" "Example usage:\n" - " --media=type=v4l2_emulated_camera_splane,lens_facing=BACK\n"; + " --media=v4l2_emulated_camera_mplane:lens_facing=BACK\n"; Result> ParseMediaConfig( const std::string& flag); diff --git a/e2etests/cvd/media_tests/main_test.go b/e2etests/cvd/media_tests/main_test.go index eb14d63fb39..0e0d1440379 100644 --- a/e2etests/cvd/media_tests/main_test.go +++ b/e2etests/cvd/media_tests/main_test.go @@ -44,7 +44,7 @@ func TestEmulatedCameraV4l2Compliance(t *testing.T) { t.Fatal(err) } - if err := c.CVDCreate(e2etests.CreateArgs{Args: []string{"--media=type=v4l2_emulated_camera_splane"}}); err != nil { + if err := c.CVDCreate(e2etests.CreateArgs{Args: []string{"--media=v4l2_emulated_camera_splane"}}); err != nil { t.Fatal(err) } From 4a59f578347c355e2973f51e87f4b2c6bc690174 Mon Sep 17 00:00:00 2001 From: Gemini Date: Tue, 18 Aug 2026 01:54:05 +0000 Subject: [PATCH 35/53] Support target configuration preset in Cuttlefish cvd load JSON Adds optional string config = 11 to message Instance in load_config.proto. Updates cf_configs_instances.cpp to emit --config= per instance, allowing cvd load and cloud orchestrators to pass configuration presets natively in JSON. --- .../cvd/cli/parser/cf_configs_instances.cpp | 24 ++++++ .../cvd/cli/parser/flags_parser_test.cc | 81 +++++++++++++++++++ .../commands/cvd/cli/parser/load_config.proto | 1 + 3 files changed, 106 insertions(+) diff --git a/base/cvd/cuttlefish/host/commands/cvd/cli/parser/cf_configs_instances.cpp b/base/cvd/cuttlefish/host/commands/cvd/cli/parser/cf_configs_instances.cpp index 3db64992ad5..2dc06fd594e 100644 --- a/base/cvd/cuttlefish/host/commands/cvd/cli/parser/cf_configs_instances.cpp +++ b/base/cvd/cuttlefish/host/commands/cvd/cli/parser/cf_configs_instances.cpp @@ -34,7 +34,30 @@ namespace cuttlefish { +namespace { + using cvd::config::EnvironmentSpecification; +using cvd::config::Instance; + +std::string ConfigFlag(const Instance& instance) { + if (instance.has_config()) { + return instance.config(); + } + return ""; +} + +std::vector GenerateConfigFlags( + const EnvironmentSpecification& cfg) { + for (const auto& instance : cfg.instances()) { + if (instance.has_config() && !instance.config().empty()) { + return std::vector{ + GenerateInstanceFlag("config", cfg, ConfigFlag)}; + } + } + return {}; +} + +} // namespace Result> GenerateInstancesFlags( const EnvironmentSpecification& cfg) { @@ -46,6 +69,7 @@ Result> GenerateInstancesFlags( res = MergeResults(std::move(res), CF_EXPECT(GenerateVmFlags(cfg))); res = MergeResults(std::move(res), GenerateConnectivityFlags(cfg)); res = MergeResults(std::move(res), CF_EXPECT(GenerateMediaFlags(cfg))); + res = MergeResults(std::move(res), GenerateConfigFlags(cfg)); return res; } diff --git a/base/cvd/cuttlefish/host/commands/cvd/cli/parser/flags_parser_test.cc b/base/cvd/cuttlefish/host/commands/cvd/cli/parser/flags_parser_test.cc index bc41537b144..7747564ce60 100644 --- a/base/cvd/cuttlefish/host/commands/cvd/cli/parser/flags_parser_test.cc +++ b/base/cvd/cuttlefish/host/commands/cvd/cli/parser/flags_parser_test.cc @@ -600,4 +600,85 @@ TEST(ConnectivityFlagsParserTest, ParseModemSimulatorSimTypeInvalidInt) { << "modem_simulator_sim_type flag is missing or wrongly formatted"; } +TEST(ConfigFlagsParserTest, ParseSingleInstanceConfig) { + const char* test_string = R""""( +{ + "instances" : + [ + { + "config": "phone" + } + ] +} + )""""; + + Json::Value json_configs; + std::string json_text(test_string); + + EXPECT_TRUE(ParseJsonString(json_text, json_configs)) + << "Invalid Json string"; + const Result> serialized_data = + LaunchCvdParserTester(json_configs); + ASSERT_THAT(serialized_data, IsOk()); + EXPECT_TRUE(FindConfig(*serialized_data, "--config=phone")) + << "config flag is missing or wrongly formatted"; +} + +TEST(ConfigFlagsParserTest, ParseMultiInstanceConfig) { + const char* test_string = R""""( +{ + "instances" : + [ + { + "config": "phone" + }, + { + "config": "tv" + } + ] +} + )""""; + + Json::Value json_configs; + std::string json_text(test_string); + + EXPECT_TRUE(ParseJsonString(json_text, json_configs)) + << "Invalid Json string"; + const Result> serialized_data = + LaunchCvdParserTester(json_configs); + ASSERT_THAT(serialized_data, IsOk()); + EXPECT_TRUE(FindConfig(*serialized_data, "--config=phone,tv")) + << "config multi-instance flag is missing or wrongly formatted"; +} + +TEST(ConfigFlagsParserTest, ParseMultiInstanceConfigPartial) { + const char* test_string = R""""( +{ + "instances" : + [ + { + "config": "phone" + }, + { + "vm": { + "crosvm":{ + } + } + } + ] +} + )""""; + + Json::Value json_configs; + std::string json_text(test_string); + + EXPECT_TRUE(ParseJsonString(json_text, json_configs)) + << "Invalid Json string"; + const Result> serialized_data = + LaunchCvdParserTester(json_configs); + ASSERT_THAT(serialized_data, IsOk()); + EXPECT_TRUE(FindConfig(*serialized_data, "--config=phone,")) + << "config partial multi-instance flag is missing or wrongly formatted"; +} + } // namespace cuttlefish diff --git a/base/cvd/cuttlefish/host/commands/cvd/cli/parser/load_config.proto b/base/cvd/cuttlefish/host/commands/cvd/cli/parser/load_config.proto index 51a1f9d137f..71a56da20e4 100644 --- a/base/cvd/cuttlefish/host/commands/cvd/cli/parser/load_config.proto +++ b/base/cvd/cuttlefish/host/commands/cvd/cli/parser/load_config.proto @@ -95,6 +95,7 @@ message Instance { // TODO: b/337089452 - handle outside of proto logic optional string import_template = 9 [json_name = "@import"]; optional Media media = 10; + optional string config = 11; } message Boot { From 9d519cd233d18b3de17749cabbf03f17b3191fa9 Mon Sep 17 00:00:00 2001 From: Ram Muthiah Date: Tue, 18 Aug 2026 22:51:35 +0100 Subject: [PATCH 36/53] cvd: Fallback to --help when --helpxml is unsupported in status fetcher Older guest host tools (e.g. Android T / tm-qpr-dev / SDK 32) do not support --helpxml and abort with SIGABRT when it is passed, resulting in empty output and ParseGflagsXmlHelp failure. Fall back to --help if ParseGflagsXmlHelp fails. Bug: b/546992730 Assisted-By: Antigravity:Gemini-Next --- .../commands/cvd/instances/status_fetcher.cpp | 33 ++++++++++++++++--- 1 file changed, 28 insertions(+), 5 deletions(-) diff --git a/base/cvd/cuttlefish/host/commands/cvd/instances/status_fetcher.cpp b/base/cvd/cuttlefish/host/commands/cvd/instances/status_fetcher.cpp index 0751f6930a0..cdaff46797a 100644 --- a/base/cvd/cuttlefish/host/commands/cvd/instances/status_fetcher.cpp +++ b/base/cvd/cuttlefish/host/commands/cvd/instances/status_fetcher.cpp @@ -115,11 +115,34 @@ Result FetchInstanceStatus(LocalInstance& instance, std::string stdout_str, stderr_str; RunWithManagedStdio(std::move(help_cmd), nullptr, &stdout_str, &stderr_str); - std::vector internal_flags = - CF_EXPECT(ParseGflagsXmlHelp(stdout_str)); - bool has_print = std::any_of( - internal_flags.begin(), internal_flags.end(), - [](const GflagDescription& desc) { return desc.name == "print"; }); + bool has_print = false; + Result> internal_flags = + ParseGflagsXmlHelp(stdout_str); + if (internal_flags.has_value()) { + has_print = std::any_of( + internal_flags->begin(), internal_flags->end(), + [](const GflagDescription& desc) { return desc.name == "print"; }); + } else { + LOG(INFO) << bin << " does not support --helpxml. Falling back to --help."; + ConstructCommandParam fallback_help_cmd_param{ + .bin_path = bin_path, + .home = home, + .args = {"--help"}, + .envs = envs, + .working_dir = working_dir, + .command_name = bin, + }; + if (Result fallback_cmd = + ConstructCommand(fallback_help_cmd_param); + fallback_cmd.has_value()) { + stdout_str.clear(); + stderr_str.clear(); + RunWithManagedStdio(std::move(*fallback_cmd), nullptr, &stdout_str, + &stderr_str); + has_print = stdout_str.find("--print") != std::string::npos || + stderr_str.find("--print") != std::string::npos; + } + } std::vector args{"--wait_for_launcher", std::to_string(timeout.count())}; From 76310e6c72f724a53176b3590681a85f26ab6f85 Mon Sep 17 00:00:00 2001 From: Ram Muthiah Date: Fri, 24 Jul 2026 20:37:43 +0000 Subject: [PATCH 37/53] Hold kernel package during base image builds This was triggering too many baseimage respins when someone needed to release an image in a pinch. --- .../baseimage/pkg/gce/scripts/create_base_image_main.sh | 7 +++++-- .../baseimage/pkg/gce/scripts/install_cuttlefish_debs.sh | 7 +++++-- tools/baseimage/pkg/gce/scripts/install_nvidia.sh | 9 +++------ 3 files changed, 13 insertions(+), 10 deletions(-) diff --git a/tools/baseimage/pkg/gce/scripts/create_base_image_main.sh b/tools/baseimage/pkg/gce/scripts/create_base_image_main.sh index ebb9e35c825..82828d4d66b 100644 --- a/tools/baseimage/pkg/gce/scripts/create_base_image_main.sh +++ b/tools/baseimage/pkg/gce/scripts/create_base_image_main.sh @@ -26,10 +26,13 @@ sudo apt-get upgrade -y # Avoids blocking "Default mirror not found" popup prompt when pbuilder is installed. echo "pbuilder pbuilder/mirrorsite string https://deb.debian.org/debian" | sudo debconf-set-selections -kmodver_begin=$(sudo chroot /mnt/image/ /usr/bin/dpkg -s linux-image-cloud-${arch} | grep ^Depends: | \ - cut -d: -f2 | cut -d" " -f2 | sed 's/linux-image-//') +kmodver_begin=$(sudo chroot /mnt/image/ /usr/bin/dpkg -l | grep '^ii' | \ + awk '{print $2}' | grep '^linux-image-[0-9]' | head -n1 | sed 's/linux-image-//') echo "IMAGE STARTS WITH KERNEL: ${kmodver_begin}" +# Make sure we don't update the kernel image or headers during this process +sudo chroot /mnt/image /usr/bin/apt-mark hold linux-image-cloud-${arch} linux-headers-cloud-${arch} + sudo chroot /mnt/image /usr/bin/apt update sudo chroot /mnt/image /usr/bin/apt upgrade -y diff --git a/tools/baseimage/pkg/gce/scripts/install_cuttlefish_debs.sh b/tools/baseimage/pkg/gce/scripts/install_cuttlefish_debs.sh index 105df368c23..12a86fb54ac 100644 --- a/tools/baseimage/pkg/gce/scripts/install_cuttlefish_debs.sh +++ b/tools/baseimage/pkg/gce/scripts/install_cuttlefish_debs.sh @@ -25,10 +25,13 @@ arch=$(uname -m) [ "${arch}" = "x86_64" ] && arch=amd64 [ "${arch}" = "aarch64" ] && arch=arm64 -kmodver_begin=$(sudo chroot /mnt/image/ /usr/bin/dpkg -s linux-image-cloud-${arch} | grep ^Depends: | \ - cut -d: -f2 | cut -d" " -f2 | sed 's/linux-image-//') +kmodver_begin=$(sudo chroot /mnt/image/ /usr/bin/dpkg -l | grep '^ii' | \ + awk '{print $2}' | grep '^linux-image-[0-9]' | head -n1 | sed 's/linux-image-//') echo "IMAGE STARTS WITH KERNEL: ${kmodver_begin}" +# Make sure we don't update the kernel image or headers during this process +sudo chroot /mnt/image /usr/bin/apt-mark hold linux-image-cloud-${arch} linux-headers-cloud-${arch} + sudo chroot /mnt/image /usr/bin/apt update sudo chroot /mnt/image /usr/bin/apt upgrade -y diff --git a/tools/baseimage/pkg/gce/scripts/install_nvidia.sh b/tools/baseimage/pkg/gce/scripts/install_nvidia.sh index 00841ac1cd8..8a28a6efdca 100644 --- a/tools/baseimage/pkg/gce/scripts/install_nvidia.sh +++ b/tools/baseimage/pkg/gce/scripts/install_nvidia.sh @@ -27,12 +27,9 @@ if [ ! -d /dev/fd ]; then ln -s /proc/self/fd /dev/fd fi -# Using "Depends:" is more reliable than "Version:", because it works for -# backported ("bpo") kernels as well. NOTE: "Package" can be used instead -# if we don't install the metapackage ("linux-image-cloud-${arch}") but a -# specific version in the future -kmodver=$(dpkg -s linux-image-cloud-${arch} | grep ^Depends: | \ - cut -d: -f2 | cut -d" " -f2 | sed 's/linux-image-//') +# Query the installed concrete kernel package version on disk rather than the metapackage +kmodver=$(dpkg -l | grep '^ii' | awk '{print $2}' | \ + grep '^linux-image-[0-9]' | head -n1 | sed 's/linux-image-//') apt-get install -y wget From 842d30660b25732d476145c370ccbd978c694fc9 Mon Sep 17 00:00:00 2001 From: Seungjae Yoo Date: Wed, 15 Jul 2026 06:08:00 +0000 Subject: [PATCH 38/53] Reduce the number of nginx worker processes in container --- container/image/Containerfile | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/container/image/Containerfile b/container/image/Containerfile index 9b6eb58922b..bcc74670df1 100644 --- a/container/image/Containerfile +++ b/container/image/Containerfile @@ -32,6 +32,18 @@ RUN apt install -y --no-install-recommends \ sudo RUN update-ca-certificates +# When setting `auto` value, nginx spawns worker processes as the number of CPU +# cores. It's discouraged in any multiple container scenarios, as it spawns too +# much worker processes in huge machines, but not actually required. +RUN sed -i 's/worker_processes auto;/worker_processes 2;/' \ + /etc/nginx/nginx.conf +# When setting `auto` value, nginx select which CPU core executing worker +# processes. It's discouraged in any multiple container scenarios, as all +# containers may use CPU core `0`-`N` when `worker_processes` is set as `N+1`. +# When setting no values, OS scheduler manages it instead. +RUN sed -i 's/worker_cpu_affinity auto;/# worker_cpu_affinity auto;/' \ + /etc/nginx/nginx.conf + COPY ./container/image/guest/run_services.sh /root/ RUN chmod +x /root/run_services.sh From 8b337d6b67f29be100cf2a363716679cee294ced Mon Sep 17 00:00:00 2001 From: Sergio Andres Rodriguez Orama Date: Thu, 9 Jul 2026 14:44:49 -0400 Subject: [PATCH 39/53] Fix xts test result assertion. - Handle tests result with "fail" value. Bug: b/533039176 --- e2etests/cvd/common/common.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/e2etests/cvd/common/common.go b/e2etests/cvd/common/common.go index 7c4ff4312ed..c827da9a8e9 100644 --- a/e2etests/cvd/common/common.go +++ b/e2etests/cvd/common/common.go @@ -629,7 +629,7 @@ func RunXts(t *testing.T, cuttlefishArgs FetchAndCreateArgs, xtsArgs XtsArgs) { testname := fmt.Sprintf("%s#%s", xtsTestCase.Name, xtsTest.Name) t.Run(testname, func(t *testing.T) { log.Printf("%s result: %s", testname, xtsTest.Result) - if xtsTest.Result == "failed" { + if strings.HasPrefix(xtsTest.Result, "fail") { t.Error("XTS test failed, see logs") } }) From 2d239a9851841406570fef1d06fbc006cc946852 Mon Sep 17 00:00:00 2001 From: "A. Cody Schuffelen" Date: Wed, 29 Jul 2026 14:18:04 -0700 Subject: [PATCH 40/53] Update compile_commands.json generator Upstream is unmaintained, this fork has continued development. Bug: b/540519007 Test: bazel run @hedron_compile_commands//:refresh_all --- .../hedron_compile_commands.MODULE.bazel | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/base/cvd/build_external/hedron_compile_commands/hedron_compile_commands.MODULE.bazel b/base/cvd/build_external/hedron_compile_commands/hedron_compile_commands.MODULE.bazel index 9bbd5435a3a..ca897581c4b 100644 --- a/base/cvd/build_external/hedron_compile_commands/hedron_compile_commands.MODULE.bazel +++ b/base/cvd/build_external/hedron_compile_commands/hedron_compile_commands.MODULE.bazel @@ -2,9 +2,8 @@ # https://github.com/hedronvision/bazel-compile-commands-extractor git_override( module_name = "hedron_compile_commands", - # While waiting for - # https://github.com/hedronvision/bazel-compile-commands-extractor/pull/219 - # to be merged. - commit = "f5fbd4cee671d8d908f37c83abaf70fba5928fc7", - remote = "https://github.com/mikael-s-persson/bazel-compile-commands-extractor", + # Upstream is unmaintained, see + # https://github.com/helly25/bazel-compile-commands-extractor/blob/1f9360db1834d115c48279d38a97f30d64d3fd4a/FORK.md + commit = "1f9360db1834d115c48279d38a97f30d64d3fd4a", + remote = "https://github.com/helly25/bazel-compile-commands-extractor.git", ) From 7358755fc3c326570e23b6ca886eafea5ab90ae4 Mon Sep 17 00:00:00 2001 From: Jason Macnak Date: Mon, 20 Jul 2026 09:47:47 -0700 Subject: [PATCH 41/53] Add and support for Guest Lavapipe GPU mode Based on valentine.burley@collabora's arsp/4898478. This introduces a couple of new guest config values to determine if various vulkan apexes are supported in order to work around the fact that Cuttlefish at HEAD currently has both gfxstream and swiftshader in a single apex (aosp/2818460). After this change is released, the lavapipe vulkan apex can be introduced and the pre-existing gfxstream plus swiftshader apex can be split. Bug: b/530070181 Bug: b/536966381 Test: bazel run //cuttlefish/package:cvd -- create \ (on main with pre-existing vulkan apex) Test: bazel run //cuttlefish/package:cvd -- create \ --gpu_mode=guest_swiftshader (on main with pre-existing vulkan apex) Test: bazel run //cuttlefish/package:cvd -- create \ --gpu_mode=gfxstream_guest_angle (on main with pre-existing vulkan apex) Test: bazel run //cuttlefish/package:cvd -- create \ --gpu_mode=gfxstream_guest_angle (on main with separated vulkan apexes from ag/41081278) Test: bazel run //cuttlefish/package:cvd -- create \ (on main with separated vulkan apexes from ag/41081278) Test: bazel run //cuttlefish/package:cvd -- create \ --gpu_mode=guest_lavapipe (on main with separated vulkan apexes from ag/41081278) Test: bazel run //cuttlefish/package:cvd -- create \ --config_file=spec.json (where spec.json specifies older udc image) --- .../commands/assemble_cvd/bootconfig_args.cpp | 20 +++++++++++ .../commands/assemble_cvd/graphics_flags.cc | 35 +++++++++++++++++-- .../commands/assemble_cvd/guest_config.cc | 21 ++++++++++- .../host/commands/assemble_cvd/guest_config.h | 4 +++ .../assemble_cvd/proto/guest_config.proto | 11 +++++- .../host/commands/run_cvd/launch/streamer.cpp | 2 +- .../cuttlefish/host/frontend/webrtc/main.cpp | 4 ++- .../host/libs/config/cuttlefish_config.h | 8 +++++ .../config/cuttlefish_config_instance.cpp | 28 +++++++++++++++ .../cuttlefish/host/libs/config/gpu_mode.cc | 9 +++++ .../cuttlefish/host/libs/config/gpu_mode.h | 7 ++++ .../host/libs/metrics/metrics_conversion.cc | 3 ++ .../libs/screen_connector/screen_connector.h | 1 + .../host/libs/vm_manager/crosvm_manager.cpp | 19 +++++++--- .../host/libs/vm_manager/gem5_manager.cpp | 16 +++++++-- .../host/libs/vm_manager/qemu_manager.cpp | 16 +++++++-- base/cvd/external_proto/cf_flags.proto | 3 +- 17 files changed, 191 insertions(+), 16 deletions(-) diff --git a/base/cvd/cuttlefish/host/commands/assemble_cvd/bootconfig_args.cpp b/base/cvd/cuttlefish/host/commands/assemble_cvd/bootconfig_args.cpp index ce76330e796..7dc8cb34fb0 100644 --- a/base/cvd/cuttlefish/host/commands/assemble_cvd/bootconfig_args.cpp +++ b/base/cvd/cuttlefish/host/commands/assemble_cvd/bootconfig_args.cpp @@ -327,6 +327,26 @@ Result> BootconfigArgsFromConfig( ? "com.android.hardware.graphics.composer.drm_hwcomposer" : "com.android.hardware.graphics.composer.ranchu"; + const GpuMode gpu_mode = instance.gpu_mode(); + if (gpu_mode != GpuMode::None) { + if (IsGfxstreamMode(gpu_mode)) { + if (instance.has_vulkan_gfxstream_apex()) { + bootconfig_args["androidboot.vendor.apex.com.google.cf.vulkan"] = + "com.google.cf.vulkan.gfxstream"; + } + } else if (gpu_mode == GpuMode::GuestLavapipe) { + if (instance.has_vulkan_lavapipe_apex()) { + bootconfig_args["androidboot.vendor.apex.com.google.cf.vulkan"] = + "com.google.cf.vulkan.lavapipe"; + } + } else if (gpu_mode == GpuMode::GuestSwiftshader) { + if (instance.has_vulkan_swiftshader_apex()) { + bootconfig_args["androidboot.vendor.apex.com.google.cf.vulkan"] = + "com.google.cf.vulkan.swiftshader"; + } + } + } + if (instance.vhal_proxy_server_port()) { bootconfig_args["androidboot.vhal_proxy_server_port"] = std::to_string(instance.vhal_proxy_server_port()); diff --git a/base/cvd/cuttlefish/host/commands/assemble_cvd/graphics_flags.cc b/base/cvd/cuttlefish/host/commands/assemble_cvd/graphics_flags.cc index 2e44a1da86f..b4a8aac7d91 100644 --- a/base/cvd/cuttlefish/host/commands/assemble_cvd/graphics_flags.cc +++ b/base/cvd/cuttlefish/host/commands/assemble_cvd/graphics_flags.cc @@ -117,13 +117,26 @@ GetGpuModeRequirementsMap() { const RequirementWithReason kGuestSupportsGfxstream{ .func = [](const CommonState& common) { - return common.guest_config.gfxstream_supported; + return common.guest_config.gfxstream_supported || + common.guest_config.has_vulkan_gfxstream_apex; }, .success_explanation = "The guest supports Gfxstream.", .failure_explanation = "The guest does not support Gfxstream. This is configured in the " "`android-info.txt` file associated with the guest target build.", }; + const RequirementWithReason kGuestSupportsLavapipe{ + .func = + [](const CommonState& common) { + return common.guest_config.guest_lavapipe_supported || + common.guest_config.has_vulkan_lavapipe_apex; + }, + .success_explanation = "The guest supports Lavapipe.", + .failure_explanation = + "The guest does not claim support for Lavapipe. This is " + "configured in the `android-info.txt` file associated with the guest " + "target build.", + }; const RequirementWithReason kHostGlesAvailable{ .func = [](const CommonState& common) { @@ -285,6 +298,12 @@ GetGpuModeRequirementsMap() { kNotUsingHostQemu, }, }, + { + GpuMode::GuestLavapipe, + { + kGuestSupportsLavapipe, + }, + }, { GpuMode::GuestSwiftshader, /*no requirements*/ {}, @@ -469,12 +488,18 @@ std::vector GetGpuModeCandidates(const GuestConfig& guest_config) { gpu_mode_candidates.push_back(GpuMode::GfxstreamGuestAngleHostSwiftshader); gpu_mode_candidates.push_back(GpuMode::GfxstreamGuestAngleHostLavapipe); gpu_mode_candidates.push_back(GpuMode::GuestSwiftshader); + if (guest_config.guest_lavapipe_supported) { + gpu_mode_candidates.push_back(GpuMode::GuestLavapipe); + } } else { gpu_mode_candidates.push_back(GpuMode::Gfxstream); gpu_mode_candidates.push_back(GpuMode::GuestSwiftshader); gpu_mode_candidates.push_back(GpuMode::GfxstreamGuestAngle); gpu_mode_candidates.push_back(GpuMode::GfxstreamGuestAngleHostSwiftshader); gpu_mode_candidates.push_back(GpuMode::GfxstreamGuestAngleHostLavapipe); + if (guest_config.guest_lavapipe_supported) { + gpu_mode_candidates.push_back(GpuMode::GuestLavapipe); + } } gpu_mode_candidates.push_back(GpuMode::None); @@ -578,7 +603,7 @@ Result SelectGpuVhostUserMode(const GpuMode gpu_mode, gpu_vhost_user_mode_arg == kGpuVhostUserModeOn || gpu_vhost_user_mode_arg == kGpuVhostUserModeOff); if (gpu_vhost_user_mode_arg == kGpuVhostUserModeAuto) { - if (gpu_mode == GpuMode::GuestSwiftshader) { + if (IsGuestRenderingMode(gpu_mode)) { VLOG(0) << "GPU vhost user auto mode: not needed for --gpu_mode=" << GpuModeString(gpu_mode) << ". Not enabling vhost user gpu."; return false; @@ -784,6 +809,12 @@ Result ConfigureGpuSettings( const std::string& guest_renderer_preload_arg, VmmMode vmm, const GuestConfig& guest_config, CuttlefishConfig::MutableInstanceSpecific& instance) { + instance.set_has_vulkan_gfxstream_apex( + guest_config.has_vulkan_gfxstream_apex); + instance.set_has_vulkan_lavapipe_apex(guest_config.has_vulkan_lavapipe_apex); + instance.set_has_vulkan_swiftshader_apex( + guest_config.has_vulkan_swiftshader_apex); + #ifdef __APPLE__ (void)graphics_availability; (void)gpu_vhost_user_mode_arg; diff --git a/base/cvd/cuttlefish/host/commands/assemble_cvd/guest_config.cc b/base/cvd/cuttlefish/host/commands/assemble_cvd/guest_config.cc index 3a30217db86..803cb1157c5 100644 --- a/base/cvd/cuttlefish/host/commands/assemble_cvd/guest_config.cc +++ b/base/cvd/cuttlefish/host/commands/assemble_cvd/guest_config.cc @@ -130,6 +130,19 @@ Result ParseGuestConfigTextProto(const std::string& guest_config_path, guest_config.gpu_mode_candidates.push_back(it->second); } + if (graphics_config.has_vulkan_gfxstream_apex_supported()) { + guest_config.has_vulkan_gfxstream_apex = + graphics_config.vulkan_gfxstream_apex_supported(); + } + if (graphics_config.has_vulkan_lavapipe_apex_supported()) { + guest_config.has_vulkan_lavapipe_apex = + graphics_config.vulkan_lavapipe_apex_supported(); + } + if (graphics_config.has_vulkan_swiftshader_apex_supported()) { + guest_config.has_vulkan_swiftshader_apex = + graphics_config.vulkan_swiftshader_apex_supported(); + } + const auto& input_config = proto_config.input(); if (input_config.has_mouse_supported()) { guest_config.mouse_supported = input_config.mouse_supported(); @@ -205,7 +218,6 @@ Result ParseGuestConfigTxt(const std::string& guest_config_path, guest_config.gfxstream_supported = MapHasValue(info, "gfxstream", "supported"); - guest_config.gfxstream_gl_program_binary_link_status_supported = MapHasValue(info, "gfxstream_gl_program_binary_link_status", "supported"); @@ -221,6 +233,13 @@ Result ParseGuestConfigTxt(const std::string& guest_config_path, } } + guest_config.has_vulkan_gfxstream_apex = + MapHasValue(info, "vulkan_gfxstream_apex", "supported"); + guest_config.has_vulkan_lavapipe_apex = + MapHasValue(info, "vulkan_lavapipe_apex", "supported"); + guest_config.has_vulkan_swiftshader_apex = + MapHasValue(info, "vulkan_swiftshader_apex", "supported"); + guest_config.mouse_supported = MapHasValue(info, "mouse", "supported"); guest_config.gamepad_supported = MapHasValue(info, "gamepad", "supported"); diff --git a/base/cvd/cuttlefish/host/commands/assemble_cvd/guest_config.h b/base/cvd/cuttlefish/host/commands/assemble_cvd/guest_config.h index f039ffecccd..054900551c3 100644 --- a/base/cvd/cuttlefish/host/commands/assemble_cvd/guest_config.h +++ b/base/cvd/cuttlefish/host/commands/assemble_cvd/guest_config.h @@ -40,6 +40,7 @@ struct GuestConfig { std::string android_version_number; bool gfxstream_supported = false; bool gfxstream_gl_program_binary_link_status_supported = false; + bool guest_lavapipe_supported = false; bool vhost_user_vsock = false; bool supports_bgra_framebuffers = false; bool prefer_drm_virgl_when_supported = false; @@ -54,6 +55,9 @@ struct GuestConfig { int blank_data_image_mb = 0; bool lights_server_enabled = true; // true for backwards compatibility std::vector gpu_mode_candidates; + bool has_vulkan_lavapipe_apex = false; + bool has_vulkan_gfxstream_apex = false; + bool has_vulkan_swiftshader_apex = false; }; PrettyStruct Pretty(const GuestConfig&, diff --git a/base/cvd/cuttlefish/host/commands/assemble_cvd/proto/guest_config.proto b/base/cvd/cuttlefish/host/commands/assemble_cvd/proto/guest_config.proto index 2f778206090..8fd1e76360f 100644 --- a/base/cvd/cuttlefish/host/commands/assemble_cvd/proto/guest_config.proto +++ b/base/cvd/cuttlefish/host/commands/assemble_cvd/proto/guest_config.proto @@ -48,6 +48,15 @@ message Graphics { // The list of gpu modes supported by the guest in order of preference. repeated GpuMode gpu_mode_candidates = 5; + + // Whether the guest has a separate apex for the Gfxstream Vulkan driver. + bool vulkan_gfxstream_apex_supported = 6; + + // Whether the guest has a separate apex for the Lavapipe Vulkan driver. + bool vulkan_lavapipe_apex_supported = 7; + + // Whether the guest has a separate apex for the Swiftshader Vulkan driver. + bool vulkan_swiftshader_apex_supported = 8; } message Audio { @@ -88,7 +97,7 @@ message Audio { bool mute_control_enabled = 1; Volume volume_control = 2; } - + message Stream { uint32 id = 1; ChannelLayout channel_layout = 2; diff --git a/base/cvd/cuttlefish/host/commands/run_cvd/launch/streamer.cpp b/base/cvd/cuttlefish/host/commands/run_cvd/launch/streamer.cpp index 5c22c264dd4..619f30a5c43 100644 --- a/base/cvd/cuttlefish/host/commands/run_cvd/launch/streamer.cpp +++ b/base/cvd/cuttlefish/host/commands/run_cvd/launch/streamer.cpp @@ -150,7 +150,7 @@ class StreamerSockets : public virtual SetupFeature { // SetupFeature std::string Name() const override { return "StreamerSockets"; } bool Enabled() const override { - bool is_accelerated = instance_.gpu_mode() != GpuMode::GuestSwiftshader; + bool is_accelerated = !IsGuestRenderingMode(instance_.gpu_mode()); return !(VmManagerIsQemu(config_) && is_accelerated); } diff --git a/base/cvd/cuttlefish/host/frontend/webrtc/main.cpp b/base/cvd/cuttlefish/host/frontend/webrtc/main.cpp index 6056860968c..934ba045de9 100644 --- a/base/cvd/cuttlefish/host/frontend/webrtc/main.cpp +++ b/base/cvd/cuttlefish/host/frontend/webrtc/main.cpp @@ -472,7 +472,9 @@ int CuttlefishMain() { std::to_string(instance.memory_mb()) + " mb"); std::string user_friendly_gpu_mode; - if (instance.gpu_mode() == GpuMode::GuestSwiftshader) { + if (instance.gpu_mode() == GpuMode::GuestLavapipe) { + user_friendly_gpu_mode = "Lavapipe (Guest GPU Rendering)"; + } else if (instance.gpu_mode() == GpuMode::GuestSwiftshader) { user_friendly_gpu_mode = "SwiftShader (Guest CPU Rendering)"; } else if (instance.gpu_mode() == GpuMode::DrmVirgl) { user_friendly_gpu_mode = diff --git a/base/cvd/cuttlefish/host/libs/config/cuttlefish_config.h b/base/cvd/cuttlefish/host/libs/config/cuttlefish_config.h index 6690f31c99b..388d77fa0e1 100644 --- a/base/cvd/cuttlefish/host/libs/config/cuttlefish_config.h +++ b/base/cvd/cuttlefish/host/libs/config/cuttlefish_config.h @@ -527,6 +527,10 @@ class CuttlefishConfig { bool enable_gpu_external_blob() const; bool enable_gpu_system_blob() const; + bool has_vulkan_gfxstream_apex() const; + bool has_vulkan_lavapipe_apex() const; + bool has_vulkan_swiftshader_apex() const; + std::string hwcomposer() const; bool restart_subprocesses() const; @@ -761,6 +765,10 @@ class CuttlefishConfig { void set_enable_gpu_external_blob(const bool enable_gpu_external_blob); void set_enable_gpu_system_blob(const bool enable_gpu_system_blob); + void set_has_vulkan_gfxstream_apex(const bool has_apex); + void set_has_vulkan_lavapipe_apex(const bool has_apex); + void set_has_vulkan_swiftshader_apex(const bool has_apex); + void set_hwcomposer(const std::string&); void set_restart_subprocesses(bool restart_subprocesses); diff --git a/base/cvd/cuttlefish/host/libs/config/cuttlefish_config_instance.cpp b/base/cvd/cuttlefish/host/libs/config/cuttlefish_config_instance.cpp index 337a9ac0f6b..68afec0d250 100644 --- a/base/cvd/cuttlefish/host/libs/config/cuttlefish_config_instance.cpp +++ b/base/cvd/cuttlefish/host/libs/config/cuttlefish_config_instance.cpp @@ -859,6 +859,34 @@ bool CuttlefishConfig::InstanceSpecific::enable_gpu_system_blob() const { return (*Dictionary())[kEnableGpuSystemBlob].asBool(); } +static constexpr char kHasVulkanGfxstreamApex[] = "has_vulkan_gfxstream_apex"; +void CuttlefishConfig::MutableInstanceSpecific::set_has_vulkan_gfxstream_apex( + const bool has_apex) { + (*Dictionary())[kHasVulkanGfxstreamApex] = has_apex; +} +bool CuttlefishConfig::InstanceSpecific::has_vulkan_gfxstream_apex() const { + return (*Dictionary())[kHasVulkanGfxstreamApex].asBool(); +} + +static constexpr char kHasVulkanLavapipeApex[] = "has_vulkan_lavapipe_apex"; +void CuttlefishConfig::MutableInstanceSpecific::set_has_vulkan_lavapipe_apex( + const bool has_apex) { + (*Dictionary())[kHasVulkanLavapipeApex] = has_apex; +} +bool CuttlefishConfig::InstanceSpecific::has_vulkan_lavapipe_apex() const { + return (*Dictionary())[kHasVulkanLavapipeApex].asBool(); +} + +static constexpr char kHasVulkanSwiftshaderApex[] = + "has_vulkan_swiftshader_apex"; +void CuttlefishConfig::MutableInstanceSpecific::set_has_vulkan_swiftshader_apex( + const bool has_apex) { + (*Dictionary())[kHasVulkanSwiftshaderApex] = has_apex; +} +bool CuttlefishConfig::InstanceSpecific::has_vulkan_swiftshader_apex() const { + return (*Dictionary())[kHasVulkanSwiftshaderApex].asBool(); +} + static constexpr char kEnableAudio[] = "enable_audio"; void CuttlefishConfig::MutableInstanceSpecific::set_enable_audio(bool enable) { (*Dictionary())[kEnableAudio] = enable; diff --git a/base/cvd/cuttlefish/host/libs/config/gpu_mode.cc b/base/cvd/cuttlefish/host/libs/config/gpu_mode.cc index 21f0af7974a..5a14b8c0291 100644 --- a/base/cvd/cuttlefish/host/libs/config/gpu_mode.cc +++ b/base/cvd/cuttlefish/host/libs/config/gpu_mode.cc @@ -40,6 +40,8 @@ Result GpuModeFromString(std::string_view mode) { return GpuMode::GfxstreamGuestAngleHostSwiftshader; } else if (mode == kGpuModeGfxstreamGuestAngleHostLavapipe) { return GpuMode::GfxstreamGuestAngleHostLavapipe; + } else if (mode == kGpuModeGuestLavapipe) { + return GpuMode::GuestLavapipe; } else if (mode == kGpuModeGuestSwiftshader) { return GpuMode::GuestSwiftshader; } else if (mode == kGpuModeNone) { @@ -73,6 +75,9 @@ std::string_view format_as(GpuMode mode) { case GpuMode::GfxstreamGuestAngleHostSwiftshader: return kGpuModeGfxstreamGuestAngleHostSwiftshader; break; + case GpuMode::GuestLavapipe: + return kGpuModeGuestLavapipe; + break; case GpuMode::GuestSwiftshader: return kGpuModeGuestSwiftshader; break; @@ -93,4 +98,8 @@ bool IsGfxstreamGuestAngleMode(GpuMode mode) { mode == GpuMode::GfxstreamGuestAngleHostSwiftshader; } +bool IsGuestRenderingMode(GpuMode mode) { + return mode == GpuMode::GuestLavapipe || mode == GpuMode::GuestSwiftshader; +} + } // namespace cuttlefish diff --git a/base/cvd/cuttlefish/host/libs/config/gpu_mode.h b/base/cvd/cuttlefish/host/libs/config/gpu_mode.h index 2461a1aaf02..3fe38c52f57 100644 --- a/base/cvd/cuttlefish/host/libs/config/gpu_mode.h +++ b/base/cvd/cuttlefish/host/libs/config/gpu_mode.h @@ -31,6 +31,7 @@ enum class GpuMode { GfxstreamGuestAngle, GfxstreamGuestAngleHostLavapipe, GfxstreamGuestAngleHostSwiftshader, + GuestLavapipe, GuestSwiftshader, None, }; @@ -45,6 +46,7 @@ inline constexpr std::string_view kGpuModeGfxstreamGuestAngleHostLavapipe = "gfxstream_guest_angle_host_lavapipe"; inline constexpr std::string_view kGpuModeGfxstreamGuestAngleHostSwiftshader = "gfxstream_guest_angle_host_swiftshader"; +inline constexpr std::string_view kGpuModeGuestLavapipe = "guest_lavapipe"; inline constexpr std::string_view kGpuModeGuestSwiftshader = "guest_swiftshader"; inline constexpr std::string_view kGpuModeNone = "none"; @@ -73,6 +75,9 @@ void AbslStringify(Sink& sink, GpuMode mode) { case GpuMode::GfxstreamGuestAngleHostSwiftshader: sink.Append(kGpuModeGfxstreamGuestAngleHostSwiftshader); break; + case GpuMode::GuestLavapipe: + sink.Append(kGpuModeGuestLavapipe); + break; case GpuMode::GuestSwiftshader: sink.Append(kGpuModeGuestSwiftshader); break; @@ -89,4 +94,6 @@ std::string_view format_as(GpuMode mode); // For libfmt bool IsGfxstreamMode(GpuMode mode); bool IsGfxstreamGuestAngleMode(GpuMode mode); +bool IsGuestRenderingMode(GpuMode mode); + } // namespace cuttlefish diff --git a/base/cvd/cuttlefish/host/libs/metrics/metrics_conversion.cc b/base/cvd/cuttlefish/host/libs/metrics/metrics_conversion.cc index 8dd2d76ad84..3fd691a3808 100644 --- a/base/cvd/cuttlefish/host/libs/metrics/metrics_conversion.cc +++ b/base/cvd/cuttlefish/host/libs/metrics/metrics_conversion.cc @@ -120,6 +120,9 @@ CuttlefishFlags_GpuMode ConvertGpuMode(GpuMode mode) { case GpuMode::GuestSwiftshader: return CuttlefishFlags_GpuMode:: CuttlefishFlags_GpuMode_CUTTLEFISH_FLAGS_GPU_MODE_GUEST_SWIFTSHADER; + case GpuMode::GuestLavapipe: + return CuttlefishFlags_GpuMode:: + CuttlefishFlags_GpuMode_CUTTLEFISH_FLAGS_GPU_MODE_GUEST_LAVAPIPE; case GpuMode::None: return CuttlefishFlags_GpuMode:: CuttlefishFlags_GpuMode_CUTTLEFISH_FLAGS_GPU_MODE_NONE; diff --git a/base/cvd/cuttlefish/host/libs/screen_connector/screen_connector.h b/base/cvd/cuttlefish/host/libs/screen_connector/screen_connector.h index 0dda9795330..d9e0f41985b 100644 --- a/base/cvd/cuttlefish/host/libs/screen_connector/screen_connector.h +++ b/base/cvd/cuttlefish/host/libs/screen_connector/screen_connector.h @@ -72,6 +72,7 @@ class ScreenConnector : public ScreenConnectorFrameRenderer { GpuMode::GfxstreamGuestAngle, GpuMode::GfxstreamGuestAngleHostSwiftshader, GpuMode::GfxstreamGuestAngleHostLavapipe, + GpuMode::GuestLavapipe, GpuMode::GuestSwiftshader, }; if (!Contains(valid_gpu_modes, instance.gpu_mode())) { diff --git a/base/cvd/cuttlefish/host/libs/vm_manager/crosvm_manager.cpp b/base/cvd/cuttlefish/host/libs/vm_manager/crosvm_manager.cpp index 36eee2741df..71957bc0cec 100644 --- a/base/cvd/cuttlefish/host/libs/vm_manager/crosvm_manager.cpp +++ b/base/cvd/cuttlefish/host/libs/vm_manager/crosvm_manager.cpp @@ -76,7 +76,18 @@ CrosvmManager::ConfigureGraphics( std::unordered_map bootconfig_args; - if (instance.gpu_mode() == GpuMode::GuestSwiftshader) { + if (instance.gpu_mode() == GpuMode::GuestLavapipe) { + bootconfig_args = { + {"androidboot.cpuvulkan.version", std::to_string(VK_API_VERSION_1_4)}, + {"androidboot.hardware.gralloc", "minigbm"}, + {"androidboot.hardware.hwcomposer", instance.hwcomposer()}, + {"androidboot.hardware.hwcomposer.mode", "client"}, + {"androidboot.hardware.hwcomposer.display_finder_mode", "drm"}, + {"androidboot.hardware.egl", "angle"}, + {"androidboot.hardware.vulkan", "lvp"}, + {"androidboot.opengles.version", "196609"}, // OpenGL ES 3.1 + }; + } else if (instance.gpu_mode() == GpuMode::GuestSwiftshader) { bootconfig_args = { {"androidboot.cpuvulkan.version", std::to_string(VK_API_VERSION_1_3)}, {"androidboot.hardware.gralloc", "minigbm"}, @@ -323,7 +334,7 @@ Result BuildVhostUserGpu( gpu_device_cmd.Cmd().AddParameter("gpu"); const GpuMode gpu_mode = instance.gpu_mode(); - CF_EXPECT(IsGfxstreamMode(gpu_mode) || gpu_mode == GpuMode::GuestSwiftshader, + CF_EXPECT(IsGfxstreamMode(gpu_mode) || IsGuestRenderingMode(gpu_mode), "GPU mode " << GpuModeString(gpu_mode) << " not yet supported with vhost user gpu."); @@ -333,7 +344,7 @@ Result BuildVhostUserGpu( // Why does this need JSON instead of just following the normal flags style... Json::Value gpu_params_json; gpu_params_json["pci-address"] = gpu_pci_address; - if (gpu_mode == GpuMode::GuestSwiftshader) { + if (IsGuestRenderingMode(gpu_mode)) { gpu_params_json["backend"] = "2D"; } else if (gpu_mode == GpuMode::Gfxstream) { gpu_params_json["context-types"] = "gfxstream-gles:gfxstream-vulkan"; @@ -479,7 +490,7 @@ Result ConfigureGpu(const CuttlefishConfig& config, Command* crosvm_cmd) { crosvm_cmd->AddParameter("--wayland-sock=", instance.frames_socket_path()); } - if (gpu_mode == GpuMode::GuestSwiftshader) { + if (IsGuestRenderingMode(gpu_mode)) { crosvm_cmd->AddParameter("--gpu=", gpu_displays_string, "backend=2D", gpu_common_string); } else if (gpu_mode == GpuMode::DrmVirgl) { diff --git a/base/cvd/cuttlefish/host/libs/vm_manager/gem5_manager.cpp b/base/cvd/cuttlefish/host/libs/vm_manager/gem5_manager.cpp index eb55a0eeff0..2d38b61701a 100644 --- a/base/cvd/cuttlefish/host/libs/vm_manager/gem5_manager.cpp +++ b/base/cvd/cuttlefish/host/libs/vm_manager/gem5_manager.cpp @@ -220,8 +220,20 @@ Gem5Manager::ConfigureGraphics( std::unordered_map bootconfig_args; - if (instance.gpu_mode() == GpuMode::GuestSwiftshader) { - LOG(INFO) << "We are in SwiftShader mode"; + if (instance.gpu_mode() == GpuMode::GuestLavapipe) { + VLOG(0) << "We are in Lavapipe mode"; + bootconfig_args = { + {"androidboot.cpuvulkan.version", std::to_string(VK_API_VERSION_1_1)}, + {"androidboot.hardware.gralloc", "minigbm"}, + {"androidboot.hardware.hwcomposer", "ranchu"}, + {"androidboot.hardware.hwcomposer.mode", "noop"}, + {"androidboot.hardware.hwcomposer.display_finder_mode", "gem5"}, + {"androidboot.hardware.egl", "angle"}, + {"androidboot.hardware.vulkan", "lvp"}, + {"androidboot.opengles.version", "196609"}, // OpenGL ES 3.1 + }; + } else if (instance.gpu_mode() == GpuMode::GuestSwiftshader) { + VLOG(0) << "We are in SwiftShader mode"; bootconfig_args = { {"androidboot.cpuvulkan.version", std::to_string(VK_API_VERSION_1_1)}, {"androidboot.hardware.gralloc", "minigbm"}, diff --git a/base/cvd/cuttlefish/host/libs/vm_manager/qemu_manager.cpp b/base/cvd/cuttlefish/host/libs/vm_manager/qemu_manager.cpp index c85c364d7ab..fa1eedbb504 100644 --- a/base/cvd/cuttlefish/host/libs/vm_manager/qemu_manager.cpp +++ b/base/cvd/cuttlefish/host/libs/vm_manager/qemu_manager.cpp @@ -129,7 +129,18 @@ QemuManager::ConfigureGraphics( std::unordered_map bootconfig_args; const GpuMode gpu_mode = instance.gpu_mode(); - if (gpu_mode == GpuMode::GuestSwiftshader) { + if (gpu_mode == GpuMode::GuestLavapipe) { + bootconfig_args = { + {"androidboot.cpuvulkan.version", std::to_string(VK_API_VERSION_1_4)}, + {"androidboot.hardware.gralloc", "minigbm"}, + {"androidboot.hardware.hwcomposer", instance.hwcomposer()}, + {"androidboot.hardware.hwcomposer.mode", "client"}, + {"androidboot.hardware.egl", "angle"}, + {"androidboot.hardware.vulkan", "lvp"}, + // OpenGL ES 3.1 + {"androidboot.opengles.version", "196609"}, + }; + } else if (gpu_mode == GpuMode::GuestSwiftshader) { bootconfig_args = { {"androidboot.cpuvulkan.version", std::to_string(VK_API_VERSION_1_2)}, {"androidboot.hardware.gralloc", "minigbm"}, @@ -446,8 +457,7 @@ Result> QemuManager::StartCommands( qemu_cmd.AddParameter("-vnc"); qemu_cmd.AddParameter("127.0.0.1:", instance.qemu_vnc_server_port()); - } else if (gpu_mode == GpuMode::GuestSwiftshader || - IsGfxstreamMode(gpu_mode)) { + } else if (IsGuestRenderingMode(gpu_mode) || IsGfxstreamMode(gpu_mode)) { qemu_cmd.AddParameter("-vnc"); qemu_cmd.AddParameter("127.0.0.1:", instance.qemu_vnc_server_port()); } else { diff --git a/base/cvd/external_proto/cf_flags.proto b/base/cvd/external_proto/cf_flags.proto index b7c8df9dd3a..177fde4b1a4 100644 --- a/base/cvd/external_proto/cf_flags.proto +++ b/base/cvd/external_proto/cf_flags.proto @@ -82,7 +82,7 @@ message CuttlefishFlags { string extra_kernel_cmdline = 9; - // Next index: 10 + // Next index: 11 enum GpuMode { CUTTLEFISH_FLAGS_GPU_MODE_UNSPECIFIED = 0; CUTTLEFISH_FLAGS_GPU_MODE_AUTO = 1; @@ -94,6 +94,7 @@ message CuttlefishFlags { CUTTLEFISH_FLAGS_GPU_MODE_GUEST_GFXSTREAM_GUEST_ANGLE_HOST_LAVAPIPE = 7; CUTTLEFISH_FLAGS_GPU_MODE_GUEST_VIRGL_RENDERER = 8; CUTTLEFISH_FLAGS_GPU_MODE_NONE = 9; + CUTTLEFISH_FLAGS_GPU_MODE_GUEST_LAVAPIPE = 10; } // The graphics backend that the user asked for through flags. From 642d0e61c4af1e7839f4e6f152703216b410a0fa Mon Sep 17 00:00:00 2001 From: Dmitrii Merkurev Date: Tue, 4 Aug 2026 00:02:45 +0100 Subject: [PATCH 42/53] Add an optional A/B pvmfw partition to the OS composite disk The image comes from the Android build when available. Targets that don't build protected VM firmware are unaffected. Bug: 536088107 Signed-off-by: Dmitrii Merkurev --- .../disk/android_composite_disk_config.cc | 2 ++ .../assemble_cvd/super_image_mixer.cc | 25 +++++++++++++------ 2 files changed, 19 insertions(+), 8 deletions(-) diff --git a/base/cvd/cuttlefish/host/commands/assemble_cvd/disk/android_composite_disk_config.cc b/base/cvd/cuttlefish/host/commands/assemble_cvd/disk/android_composite_disk_config.cc index 2c31ea21708..f5743b2e9d3 100644 --- a/base/cvd/cuttlefish/host/commands/assemble_cvd/disk/android_composite_disk_config.cc +++ b/base/cvd/cuttlefish/host/commands/assemble_cvd/disk/android_composite_disk_config.cc @@ -50,6 +50,7 @@ constexpr struct { std::string_view init_boot = "init_boot"; std::string_view metadata = "metadata"; std::string_view misc = "misc"; + std::string_view pvmfw = "pvmfw"; std::string_view super = "super"; std::string_view userdata = "userdata"; std::string_view vbmeta = "vbmeta"; @@ -83,6 +84,7 @@ Result> AndroidCompositeDiskConfig( const std::set ab_partitions = { kPartitions.boot, kPartitions.init_boot, + kPartitions.pvmfw, kPartitions.vbmeta, kPartitions.vbmeta_system, kPartitions.vbmeta_system_dlkm, diff --git a/base/cvd/cuttlefish/host/commands/assemble_cvd/super_image_mixer.cc b/base/cvd/cuttlefish/host/commands/assemble_cvd/super_image_mixer.cc index d53a21ddd08..359a1134757 100644 --- a/base/cvd/cuttlefish/host/commands/assemble_cvd/super_image_mixer.cc +++ b/base/cvd/cuttlefish/host/commands/assemble_cvd/super_image_mixer.cc @@ -48,14 +48,23 @@ namespace { constexpr char kMiscInfoPath[] = "META/misc_info.txt"; constexpr char kDynamicPartitionsPath[] = "META/dynamic_partitions_info.txt"; constexpr std::array kVendorTargetImages = { - "IMAGES/boot.img", "IMAGES/dtbo.img", - "IMAGES/init_boot.img", "IMAGES/odm.img", - "IMAGES/odm_dlkm.img", "IMAGES/recovery.img", - "IMAGES/system_dlkm.img", "IMAGES/userdata.img", - "IMAGES/vbmeta.img", "IMAGES/vbmeta_system_dlkm.img", - "IMAGES/vbmeta_vendor.img", "IMAGES/vbmeta_vendor_dlkm.img", - "IMAGES/vendor.img", "IMAGES/vendor_boot.img", - "IMAGES/vendor_dlkm.img", "IMAGES/vendor_kernel_boot.img", + "IMAGES/boot.img", + "IMAGES/dtbo.img", + "IMAGES/init_boot.img", + "IMAGES/odm.img", + "IMAGES/odm_dlkm.img", + "IMAGES/pvmfw.img", + "IMAGES/recovery.img", + "IMAGES/system_dlkm.img", + "IMAGES/userdata.img", + "IMAGES/vbmeta.img", + "IMAGES/vbmeta_system_dlkm.img", + "IMAGES/vbmeta_vendor.img", + "IMAGES/vbmeta_vendor_dlkm.img", + "IMAGES/vendor.img", + "IMAGES/vendor_boot.img", + "IMAGES/vendor_dlkm.img", + "IMAGES/vendor_kernel_boot.img", }; constexpr std::array kVendorTargetBuildProps = { "ODM/build.prop", From 407a84481f3c98f0ff9f436b59dd3c1d24fa67dd Mon Sep 17 00:00:00 2001 From: Dmitrii Merkurev Date: Fri, 7 Aug 2026 18:03:48 +0100 Subject: [PATCH 43/53] Add --enable_pkvm flag to provision the guest as a pKVM host When set, pass --nested=on to crosvm so the guest boots at virtual EL2, and append kvm-arm.mode=protected and kvm-arm.protected_modules=pkvm_iommu_temp to the guest kernel command line. Also disable virtio-pmem for pkvm guests (host writeback of the storage-backed pmem files invalidates the guest's nested stage-2, making the guest extremely slow) and keep pkvm_iommu_temp.ko in the first-stage ramdisk during module redistribution. Requires a nested-virt capable host, a crosvm with --nested support, and a guest image built for pKVM. Bug: 536088107 Signed-off-by: Dmitrii Merkurev --- .../assemble_cvd/assemble_cvd_flags.cpp | 5 + .../assemble_cvd/assemble_cvd_flags.h | 2 + .../commands/assemble_cvd/bootconfig_args.cpp | 24 +- .../host/commands/assemble_cvd/flags.cc | 10 + .../commands/assemble_cvd/flags_defaults.h | 1 + .../assemble_cvd/vendor_dlkm_utils.cc | 1 + .../host/commands/cvd/cli/parser/doc/vm.dot | 1 + .../host/commands/cvd/cli/parser/doc/vm.png | Bin 317333 -> 335952 bytes .../host/commands/cvd/cli/parser/doc/vm.svg | 378 +++++++++--------- .../cvd/cli/parser/golang/load_config.pb.go | 53 ++- .../cvd/cli/parser/instance/cf_vm_configs.cpp | 12 + .../commands/cvd/cli/parser/load_config.proto | 1 + .../cuttlefish/host/commands/start/main.cc | 1 + .../host/libs/config/cuttlefish_config.h | 2 + .../config/cuttlefish_config_instance.cpp | 9 + .../host/libs/config/kernel_args.cpp | 5 + .../host/libs/vm_manager/crosvm_manager.cpp | 18 +- 17 files changed, 310 insertions(+), 213 deletions(-) diff --git a/base/cvd/cuttlefish/host/commands/assemble_cvd/assemble_cvd_flags.cpp b/base/cvd/cuttlefish/host/commands/assemble_cvd/assemble_cvd_flags.cpp index 96778f9bdec..d6bdc7681f0 100644 --- a/base/cvd/cuttlefish/host/commands/assemble_cvd/assemble_cvd_flags.cpp +++ b/base/cvd/cuttlefish/host/commands/assemble_cvd/assemble_cvd_flags.cpp @@ -339,6 +339,11 @@ DEFINE_vec(protected_vm, fmt::format("{}", CF_DEFAULTS_PROTECTED_VM), DEFINE_vec(mte, fmt::format("{}", CF_DEFAULTS_MTE), "Enable MTE"); +DEFINE_vec(enable_pkvm, fmt::format("{}", CF_DEFAULTS_ENABLE_PKVM), + "Provision the guest to run pKVM so it can host its own protected " + "VMs; requires a nested-virt capable host, --vm_manager=crosvm " + "and an arm64 guest."); + DEFINE_vec(enable_audio, fmt::format("{}", CF_DEFAULTS_ENABLE_AUDIO), "Whether to play or capture audio"); diff --git a/base/cvd/cuttlefish/host/commands/assemble_cvd/assemble_cvd_flags.h b/base/cvd/cuttlefish/host/commands/assemble_cvd/assemble_cvd_flags.h index d0501b7fde3..53419829155 100644 --- a/base/cvd/cuttlefish/host/commands/assemble_cvd/assemble_cvd_flags.h +++ b/base/cvd/cuttlefish/host/commands/assemble_cvd/assemble_cvd_flags.h @@ -160,6 +160,8 @@ DECLARE_vec(protected_vm); DECLARE_vec(mte); +DECLARE_vec(enable_pkvm); + DECLARE_vec(enable_audio); DECLARE_vec(enable_jcard_simulator); diff --git a/base/cvd/cuttlefish/host/commands/assemble_cvd/bootconfig_args.cpp b/base/cvd/cuttlefish/host/commands/assemble_cvd/bootconfig_args.cpp index 7dc8cb34fb0..04151bb83d9 100644 --- a/base/cvd/cuttlefish/host/commands/assemble_cvd/bootconfig_args.cpp +++ b/base/cvd/cuttlefish/host/commands/assemble_cvd/bootconfig_args.cpp @@ -263,15 +263,23 @@ Result> BootconfigArgsFromConfig( } // TODO(b/217564326): improve this checks for a hypervisor in the VM. - if (instance.target_arch() == Arch::X86 || - instance.target_arch() == Arch::X86_64) { - bootconfig_args["androidboot.hypervisor.version"] = - "cf-" + ToString(config.vm_manager()); - bootconfig_args["androidboot.hypervisor.vm.supported"] = "1"; - } else { - bootconfig_args["androidboot.hypervisor.vm.supported"] = "0"; + switch (instance.target_arch()) { + case Arch::Arm64: + // The guest bootloader reports the hypervisor properties. + break; + case Arch::X86: + case Arch::X86_64: + bootconfig_args["androidboot.hypervisor.version"] = + "cf-" + ToString(config.vm_manager()); + bootconfig_args["androidboot.hypervisor.vm.supported"] = "1"; + bootconfig_args["androidboot.hypervisor.protected_vm.supported"] = "0"; + break; + case Arch::Arm: + case Arch::RiscV64: + bootconfig_args["androidboot.hypervisor.vm.supported"] = "0"; + bootconfig_args["androidboot.hypervisor.protected_vm.supported"] = "0"; + break; } - bootconfig_args["androidboot.hypervisor.protected_vm.supported"] = "0"; if (!instance.kernel_path().empty()) { bootconfig_args["androidboot.kernel_hotswapped"] = "1"; } diff --git a/base/cvd/cuttlefish/host/commands/assemble_cvd/flags.cc b/base/cvd/cuttlefish/host/commands/assemble_cvd/flags.cc index dc2912fb11a..b0064fc29b9 100644 --- a/base/cvd/cuttlefish/host/commands/assemble_cvd/flags.cc +++ b/base/cvd/cuttlefish/host/commands/assemble_cvd/flags.cc @@ -573,6 +573,8 @@ Result InitializeCuttlefishConfiguration( std::vector vhost_net_vec = CF_EXPECT(GET_FLAG_BOOL_VALUE(vhost_net)); std::vector vhost_user_vsock_vec = CF_EXPECT(GET_FLAG_STR_VALUE(vhost_user_vsock)); + std::vector enable_pkvm_vec = + CF_EXPECT(GET_FLAG_BOOL_VALUE(enable_pkvm)); std::vector ril_dns_vec = CF_EXPECT(GET_FLAG_STR_VALUE(ril_dns)); std::vector enable_jcard_simulator_vec = CF_EXPECT(GET_FLAG_BOOL_VALUE(enable_jcard_simulator)); @@ -900,6 +902,14 @@ Result InitializeCuttlefishConfiguration( vhost_user_vsock_vec[instance_index]); } + if (enable_pkvm_vec[instance_index]) { + CF_EXPECT_EQ(tmp_config_obj.vm_manager(), VmmMode::kCrosvm, + "Only crosvm supports --enable_pkvm"); + CF_EXPECT_EQ(guest_configs[instance_index].target_arch, Arch::Arm64, + "--enable_pkvm requires an arm64 guest"); + } + instance.set_enable_pkvm(enable_pkvm_vec[instance_index]); + if (use_random_serial_vec[instance_index]) { instance.set_serial_number( RandomSerialNumber("CFCVD" + std::to_string(num))); diff --git a/base/cvd/cuttlefish/host/commands/assemble_cvd/flags_defaults.h b/base/cvd/cuttlefish/host/commands/assemble_cvd/flags_defaults.h index cb10cfbbb69..1bf2d62bef9 100644 --- a/base/cvd/cuttlefish/host/commands/assemble_cvd/flags_defaults.h +++ b/base/cvd/cuttlefish/host/commands/assemble_cvd/flags_defaults.h @@ -100,6 +100,7 @@ #define CF_DEFAULTS_SECURE_HALS CF_DEFAULTS_DYNAMIC_STRING #define CF_DEFAULTS_PROTECTED_VM false #define CF_DEFAULTS_MTE false +#define CF_DEFAULTS_ENABLE_PKVM false // Kernel default parameters #define CF_DEFAULTS_ENABLE_KERNEL_LOG true diff --git a/base/cvd/cuttlefish/host/commands/assemble_cvd/vendor_dlkm_utils.cc b/base/cvd/cuttlefish/host/commands/assemble_cvd/vendor_dlkm_utils.cc index 5706837a937..ccc5216029a 100644 --- a/base/cvd/cuttlefish/host/commands/assemble_cvd/vendor_dlkm_utils.cc +++ b/base/cvd/cuttlefish/host/commands/assemble_cvd/vendor_dlkm_utils.cc @@ -131,6 +131,7 @@ std::vector GetRamdiskModules( "vmw_vsock_virtio_transport.ko", "vmw_vsock_virtio_transport_common.ko", "vsock.ko", + "pkvm_iommu_temp.ko", // TODO(b/176860479) once virt_wifi is deprecated fully, // these following modules can be loaded in second stage init "libarc4.ko", diff --git a/base/cvd/cuttlefish/host/commands/cvd/cli/parser/doc/vm.dot b/base/cvd/cuttlefish/host/commands/cvd/cli/parser/doc/vm.dot index 9b998fa9133..4212c5b055b 100644 --- a/base/cvd/cuttlefish/host/commands/cvd/cli/parser/doc/vm.dot +++ b/base/cvd/cuttlefish/host/commands/cvd/cli/parser/doc/vm.dot @@ -16,6 +16,7 @@ graph { vm--config vm--memory_mb vm--custom_actions + vm--enable_pkvm vm--vm_manager crosvm_binary_dir [label = "binary_dir"] qemu_binary_dir [label = "binary_dir"] diff --git a/base/cvd/cuttlefish/host/commands/cvd/cli/parser/doc/vm.png b/base/cvd/cuttlefish/host/commands/cvd/cli/parser/doc/vm.png index 6fbb93215eb8f6da561e338c0142bcd2079907a5..d4f063f1850ff2504945757be6f3b422db9ee97e 100644 GIT binary patch literal 335952 zcmZTw2RPPk+rLXmG8@Pqr9~)v7K%2Kkgd#8$|$?+otB2OLlP>x>`_t3Dr7b!LJ67Q z?-I}V9mn^)eaH8{Pu%x^T-SO2)_DbL99E;JWv8W3DD?Z(RkbLTWwsOwjS>wt{>{l- zt7!25sLc+jsZ!?1e_~!HU8hiZDf?7+YhR2S_;g8E`%jP3u#_Af-94eDSAsZtt_0}Q z1gyG3`>^HwmIH@=ckDQ{O?WE%Lwtwbou-!4yU%DAbo_9USaSTlx&3a{{kwSEcQx;3 zv$$=#eqwqy*Z3=I+?F8DtK&Z|z3V+Eec{~{XI;{zahYgyULPi2{(t|(NtS5zQ&boJ z8J){~%(w72HY&Q!Ow9lO$>OWjTCwmeHrpPhrfTZx1^)VVURy^e?%_jf_E74krl!d= zK1`cMM9z*Xnwy)y`tobb|!U&vhDP|MmN~rhx&SuksRK<;(BiYprEvjZa8eM(ewD>rGnxS+{Ooa%!sU=R6@H zA>Qk+P0Y=yPMkO)EhAG>QnKW}tm74LZz@hMuI|sDm#L|#UA%a)xT$GfW##llM+Doj zwZ^}1Yvew5>=@s+ZL2@Jd) zl`XBWXJ%kv$jHw2GuZB*l_ha<$9nu37#JW|U|~Uh^ypDteSJyU?9fnpI{LY}8h$*8 zIxF$e>@C~2QBjh$w_1s_&jfIV?xn(?M6JN5Pj|RmH)i1Gq}cP!PoDI7cV8~vw&lq= zXJ`L{0=az0AAUwJU1FVwI);abt#0_XDlI;!#)rqWwRt5Z)}^GR7RN$J?{DQwGtc2f|N7Mv5akqfihkksuTM-&ly?5f zsimcLZlq^VLP7%XrcEo9X+E^Im9@2TymTFJW?kbxIl8;{fr6=pg`nf8j`NRZ;ghFM z@$KAs)Y#;drKNy?0F{JAjj0*A>DH`SlM>&ckg>SzUVr}fO@NPY z$;ilvy1M$V{rhSAfBfj~=~=3zq%``Yg|VZfWBB)P@0=W|P2XNJ%HC(VbLWow;lq1f zTx8$Be}C?4&HBx2X>Z@YZPHbInTCdDmx&4Q-f-^F!}n$Paow>id+HZ3|BwD5YwImx z+zLV7D;RtF>f<+W-t3i^C*w!A{)(3uW!bW2CKJQmLQML%nU?D5>8T$)*vM**ZxR(3 zFE74K#mvIuXWv`N$II&_aJH4Q_=ZN+6Y*fSZlztp$gQfSwVIBeUd(OcTnL90!|vU? z*>;>%_kR((&t~JsjrhRwO!KO9!(F>iT3VL1wzBi_@v%wSaXxVA-y$t1cYy1eikY6u zzcnkoT|t3M&iQBg*kD`4ojWTxZQA7H>ucIm9>^x=By{@BnZz*loIIC5Tgm-=_@K+F z=*DJ~#XdVbdt26V>jU>OJ#3PFT$yDi|9zrztVWkVk4Nzlr5T?Ck=tYOf8=K$9*GV! zE%UQ4yyK*r+Qcs_%P!|Mfcsq$)9{^%ojoY;!ndB3qz64mA99QRcheeJ!T#w*v+TG; zA3Vbcu0LgJZi`VZS+WF=>xL}1!iJmseWN{R*UwG16rGzGHqFh?@A(pGTzNp`WqDfy zH}iiVwJRxPXRORB0?q!&(ZC7*^Jwx27MJ7U}MC%ij$tX7&HrqbTJ&Z6e_ zsh-40qf%^-#IW%X|2?Jgjaae*YGLKM_Pt$weE|sx z8wNfVuwK4=SxYTm$HLAojMdnU+1lEA;%C9ox#(z8$x=0+3R;2gz^h`0=f|Gck|N3AXAY>TnTg$ox_dd0E#uHX@ye0z6)0{0M#Ws9Pr-LE^yu=vq7 zJxS3X%2rmJ$xd6d>9G9Mq!}T@{I$w76B85d_hii(t;807IgCOG*nmL7?xwk_Lh?(AG~;FeHH7?+%hsVSdh z!d@Sy(W8X0^GB91U(P1$ zu$h{HGaxxRnWgCFPy6zSg^sn1g72=1lDW{;+v_b-IHBAxJ$n0`y?sfo(p(5`e|WrK z@xL}oDaQ7QxOVMID2G%jUg|ZvND}${4iB2eLQcS_Rc~YOI znlmJ~bLX0dhlf;>4&P@_o9lh*^2cUIY&LiHj^zXEu|K!vFYUm$npj&0#>DWJS5--U z{OOTiegEmUwLuoAT$nsOJTCr7%gMlRX=`iC|LVBZEoBpW)2&GuqlWD7=c3eFFCA6Pj9D{DsrM4wzyM-P&&0y1~4x5Us0Xq_=9% zsZ)v47ruswV&kK5@(T$aWJ4wD^qhP7+I41TrXu@H+g-;)*d4xUX=&K*Yt+IxnYZ5D zKRx*)onKsB+u=v^q1$)ve3Iz>^rZUJ(;Pp*7E=`e!kMu)9T_9n%Ku(#mVT&@&$5H} zWsg0j+n>0a$9C&Ypr%w6usrYq8&rNT#v9ZaxIMQP=_yhIg3RbI-urTxL)mMgx z&!J>VtlzWa{AcwSzu(DaJbQ-gr(zM-_xbj~mElKoTEP#Rt2vz>9H=Kg2L;R49Fbpg z|L_X@^J1iugRG}-(ViVvQ+`SO663A2wR6*qZ>p;^?LNtdaLKXg=;*MCnovBZN7UA? zT`O*DJpQJG9WQ|ieF%>;>&-~(&c$lu6BWhT=O8;VIl2E$|z6tC%Nx0(Ea02)puj~B09-QC5KBL;@=qQ1{Q1kZf(8NybT*0@0EI*#`zIpTJtaIqku*HH>0!T;E(AC|nN1dp3 zsp=2?#<$)qYn^x6_ozPB&!YYPtyWD(hXtU6&!$s(s?XvnpC_3FC33zjd&T5ZocI5dX$*V|+< zzA)aobElAQ2Bo5+Vq)M~ZN{0lY>V2Q29xQD5lY?3FjfHOnwpvw?=~kMO*$-*w2md~%RkMxEsDb@vCyG3@t?<&?Fw4CI}kIT^%N2Y(*mNho6#Uiz>H^+N3{roCo zvyf0ZiaIUOc$!XdZ&kR!jvc>Z$6lJ0EY;Q3?Rq)hp`xx%<1#kzch}V4zW8vHvuDFM z9=O#7D5a6wq<-W`)$dv*k?(^xjQwad*uV#$@fdgT?VA?g`mY_?2w*MxMnptRd{2tj zAG{syF_{7?L?b07W&g8XMhtZkykR3Moa(uA83EzpEoY0Ihm2;%=&R8UD!w-)-Fxgg z{>j;wDem z<*%=A;_06}X<-qB|F+83)^?`1Dn35G;5_gWtR;6Jtw^oI{EU~_+e{{|Tk zS2JE8)tg%uAh8TVC)sB^!*1MI3$mfkmGo(Hq>5+cPm6Ky^xxlFYSwEc&$RlG##|M~ zrGlGiv~QJPToDOL^;Vh8?@-|sgXiCB;~1S(=Jo3d%{X{Z z@=(9-wW(UqS?_(<1x@=KQ*`srC*msT7q6l*0F;9u34n8XKqmG5`>)Ar6=a|nefapX zyX|aI1u&=S>C^V}x7{nI#RnRRpQxE>z9AB3XCeNXDFUo79YfT@bMm<6yB zwsq@PQS(Z=DEUjPK{6_B(_d2KD+pLQuC48Z^=CHJ@sa?KTS9uI-TP;;{CljQB0#bT z3UvE>o)l6*_~OI^kqKdY&fH*HO1=un|6R0FILcmT@}*t>i;wmnI8a~Y>3J|(kqba* z_|Kn;o{C^i>~lwP8x?FT(rIh%NimAN7+wmT<8$>YQ;K=ki5K)i|1NrT$IhMTQ~|lU z(rC!Mpon|-?(OR=Qd&wyWs223R5Zu^<;$0gf0~YuG@m#N(z(0;!-fbfr(W>Ls#q0& zCQi-}3EO596i%%woAJfc=cu7flaQ3uJ2BEL?J+Ig)7wjE?y6O*=r|pzz4C@?YYdZ z<3D}zhOxHAu=GQClpa(Zl6%->!_37M3i93aDnfuT#E|tn$!-WsaPe7uj0$_j+38oW zS;Nf15eyu)VbdlR!RsaHG{ECDD_52TFbkO2*i5R2dE$ajw`J24>T)Q z!-FN)k0`$GdB_EkqAEf_E#tzs!<^FRD2|Sfgh&xSvE}H)U4qy5agAhFEilF8`v(pj zPyt*wGdE{uW%cjxx4G!zf*Q6IP)Aimg9(Lq!|N>bDh6OODsV-#eo`7CDENaSmNYeG zHSN?qiY1Vc&{Y?!B7Jd~7yX2aZy6p?iip*~;9z3d$Jj;wYh#IZY!6ykUS7^CDaiu$ zWBc~)H1za)@cfmPmAgKF-r!iX7i;y;sp6EQNgBtF`I7!z9>Bc7cJm#+^E=is#A2}& z%}#E^a*Mcn)e9FJlblS0&zj^H-mt-EdFX!+HjC=}_wNB=VS90tc)lP7KFk7pd4+`N zVq;?o?7+@X2)ktbTwnNbl=S6zwQzpGb=K_$UWb!ZTAmm(v$4^DiO_M&v!N{cKq+Xn zZ+i(~VesN2^S9b)HD%?cq{iIbzg$jEj*dr>6Dx#f)hh4s@FN9(xm?;8v9gUf>g>76 zQEOE-HS@XInOCn~?Lx;Cbs4n+5hiRdBQrBX)*_fRE>O`?0R{3T6SY>VsHlwgH?1Oo zK0RH;&E38G%a`TO&d#@Jok_zU7&vW^@34|p#7Gr-0^x!^J!X_$<3B$!Gcm=8SiN}p zk|0leoBTD48|jP>y7a+=bYlY_z03R=yDc^BbeSQ6hEL+wvPMItD`Ld)a5hVeeX^Ew!Wr{%dHf%3QYkTm~PmGJ6h)9wz zfaJ!jq{M^Oo#Q#3m6PKiA20Cu@nc}V6;KNC2Oas)P$_ycheOa$Z_=mYnHKSYFk3dsg|Pt#aBub`mp(gzKr(l=(&FE$VT-QWYLW4@mXoO{ay*NBRV?bg+0BYfvzlr(d8cD9z9+vBE| zmLI_peu;QsxNe&)edA=vpUR0^v2k(A#u=13VT0MevGZTYepNO$Y8#J2?CcNb<>26O zXNC^u3k6DoeXzH$j|Tb;)KQ(>t&KX1OW#EmyNk5FGi{QbvJNzrm6bG%j8zRsltO`R zboKQ1aYY2Q{#WLOlM4&E0|NsIcFJ&{a!PKpnV6a~Z+@(IaqOd|jMCbkjs*0HRV-|eK1sZIrJ2z+ggTdrwyM|pmin#Hf5RPy!p4G0M-Z!z{nCGxdyc-Y-JH!DTZoufE^|1N3Ee_E&G#n-Q2 z6LoF?It(!^E(?s$5KJ|3q<3f9>PP{mFs}7AY+L_{_5V+czj`6HCCq zy`j+JN|UK}-jJot-<78Aqm+~q=T7$(c#PzJK)wQkgUc4+_p@X^{@3;=7p{N?TlmA% zQ>%2+jY8w%_z9xHChKcR3U90r2w*o|Q1QYgKv)SXv2A`#7O+L_gV6B~S4MoamYM*6 z{v!Jr)!iyAOeBv?j~SQ7#zvE$?RmO|ZZZZ22GE~WN0SyhY`r;I+MRB{>1W41=UA}> zb)Q=?8@UcjK;=Ea6&lc2I9&f}UXmQu&Gnd(Rh*l?aJu#R%JX@g=`ViK8hOq*e)#Y~ z9Y2|@C%y2FTC-3c39lm1?cP0(<|l^1DBY#_xBaN zZ5wGiZrqKQ4}h?QFme3Sn)7+{-zyxnu-r87=^Q=k{q~+zZyBSK4?a0Hy)XzEs;s$L zhg@Lzvc*rl4iuAVS<4MN!FlP@rQ16#8FZc)tRzJ)UQ_Ovu`weW5e4NZIW5iiaFX}_ z#P?^9!X>$T_in*Yl@#r`!ot}nohZZpzP=TPMQ5RFL?3@$SEn)ed5AXKUyVWs=89J4 zot7s2&*^xamd1ylhl7JYF!RfD&+06$g|eCaR@!NR4RTEo%ANeoXhT3?AkqI5!}c($ zr#8jGyMcysHzpW0~a zL#?6TafgnDg#|c@ilTesMA@rXc9iF(6v!xiKD*E@p6jR0xc`l?kGCkLxaMN^ZRG&?|{&tJbvZaEng6r`c8ogl)+4n><- zOJieWljpna5=(ek^9&g9MgrgE&S;^7rDz`t$}G5vzHuto@dwNP{rjQIv{@O4g@sL4 zpof#|ad7Yn4qk=j(AC|&1nbIu{a!}@g~hY)A$%PGlyb6BI$pZ=qLWnktXz{2))b3Y z$p@T(HJp3tw;;Jd?9F~-Ru-0iwJ$ z54VfWPRFNXzY@@}efwT0vg87_wBGmq!A|0M`xnicTohCxhwtzA%(edOyu+iT(+v>^ zMvWI2P*YQ5V;3QrLF={=U1Hrf9g~h1mmu|BgP@-dW073s`7isgZD`HCeroh=C(sdxT&~U537ln`3>*0Y>&^% zEqXPLLF|Hz9#exkn&6{*f?2vhId^_(ILl3pN3@b3ks%>;1Xf9%?P#oB+1u3>Gk3Ke z(04D-T|+}dnIkK+*r1ERx5J}M(%k)F*s*L`-Pf;Q$>o8ezIgGXF5OsZbg+#Tz)5uH z&g&CG`izUEWS!-^sFHhU3j?88o1nK&e7=69tEY$G@v&1nfaaDhThOyr^!3?y?AUSj z)-6ARR_E@Y%;{E1kBp2gyz#w0eg!t>#=}QOjsO1rJNZjcPL6}f%J>zJxfy53f7n{z z4@AM)h%+woV3R(_3yjNCtrfAbJ`}Xze_n)qlIc2b7s9Q;jyoX`6zgL89-YXA2}Nj%A}yF>uPrJGr440I5`+v{GV4?Nb?wee{TS z-@bj)j{P?ZV>DB=vFVG4yUYH>Q^TvQX{!qO83SJR&vLAUjB)kG4IkJ-=&A%N3G5Bo z1x9$~%9XmDv&JdCvs)JEM57su(~NW7$}=y-VT8$Wa&qEHTR?$6i=tTqnrwd}Q!H>X z3jqB~``9sp-a{3&U0hw~!Bn#9;5D7p3N+7izdrASdfz+xy#eh8d$JU)nVFkA4BWg7 zXtzH(bn#C8QClAteX$wTj*366$5l{nDh>2_pF5=|sU%EP{ zn6FmIc97+|cKtdt4^KGAM;By7^tOr&(=zB{mtjv!iY2iutZ5gMKY#vAd{deWgj$0} z#>V40EoOAFdwJNhzuv8_`h;f#!<7IU#x~h>|M(HSa*ZGY1xumhd|6hkx>_@}2?oJt zay?zeOR#}s7CcGp4{tb-`>zErE}yG-;z9qFE)G+(H7JTV%ZiMB(;rm68E&*xR&Uj1_f^CKrFF20!lRSjpU1U-yMZXjGK z=KG#tjYF9w;u4}BMD8b#8$AcUXH_}M1U~a>WMqaPP1nz#VYnyL zFK=!N*-)^X=YNOe?2F5+Mi-aJ$jIns*{lm@clrE(+&^x0*LQQo>;>{52?f9w2zHs! zsgt!Iu_%Pu2mcJ67x=h23Y-Q@OMO>?>XUUs*pil-%}!#f5N%z>kFKO5n6;klTmemj zk|M5O7jO(&(cJNys`x6O3KN7U2=Cnxc&o6}MqmgfRm=)^Ej&&eEUgu$rlz+Q-DOKl zOV53OzmY}4a~KTG3_VTv#YHiwCna%y$yE1bE(oF?Kr&~9ZW1Nu{AABq^#Wd|P>|Ii z{h$t7=2{jOBDG*C?12uF5Y}u#;5IZZNtjnB+@?pW=3C`^u4BiK_rf;uii~6>>6F1i zF}N86okcw0-l5sTTeg%yf%O9bD}l}r3~_tMDI$Y>I9UX>=3;NCR9(CpBTO<`sU4>bCBK$V+JEY z*}kph=@Eb8s9ki1)RrwP%_~DLBSQo43(n!yt5@qD|Co-MdJ+A*@LpSb70SmH8ew%q^ky&i+{853J8Ajg(nGzLo?l<8|DS)^={(!kVrgMv*81GKuQBDi$9?5k zE1ieUJzu~2nOB9G61h{!Lmslj?6BOr`Hk1ujik{2i>|KVm8&w%Drhwg4TT*OB)_$0 z*_NXBlU=5zmX{Q1s9yc@r9+b7OiGAr5sRxWLKMvoLq2n^5$6W zt$Qpi9^#b*iT)$7HV%ic3m(GH-Pm%J7&N{p*H{DVDCLllD-!lyhl&+MeAgX2v?xqS zUbtMh?S(4~Gt#%Hs0iP`7U~2H$w1UiTD(FC!hsgXLth7;<$WXeEimI<&S%{&R#~kU zb0Ju)K2Z8d8tUFaOJ}Ds#M3mrZ_)Sf3nN?Ni^3v({&N7nuLr1L9ey$n7gJhOGf?EGKM&kV_o6`;wZ&wYW1_ZMRkZX}$N2yTK0Z}WoM zY{m1ph0h03SOuL_o$Jd3^62~+c{)zILsa9qDFM5Ug>u(T8ViI8WT3RR_DGQ(#J{Cp zsG4fmXTmt74jV5McP{Xpo9YbBPI>fbHHsMSOc{HqzeUO|AUrV8`nh|N$ILQ{{jblj z1zTc{L@OTJfq()Hg@5D5#QI5N&zWNsCPhWXLmd}H-hQ;aP+K5#>g|lt6!gDU6tj{m z%R{pR!^2ta?Cjpoaz)EJKBDkC4Rw67nn5-3y>sUy)lG>N44hUve%U>ZDMy!j!A)^V zo>^$c{V`5I+qWQ}<{KOwjP?)=ALa#oZDOlBxRlV}+dcUg-215%93Ur@Yyj2x~z0O7S!PI;lo;0xgvO=64`d29?j_?#bDl^YyY9ZIo;zP6!gtE_mj+8W#z-y z27*9(2uE64{>YI4IX2i{^uzvyO@UukG{C#$-v?P)j`8XA^z1 zL9Q05X*WE~p}RA7KP{sfFLaEbFKQ_)xwi2@Oug0cTd7V8h3Kqs9;W}Kd!8AyKQ?a; zgUmL4o?@JIu6+Og*X52D7UZpzMyF*LScz=FhJIY=da(t z2f{Bog!ffZTudQV54M1&kx>{5<8B&aA9O*qSV2K8Eop9MfrdiVfQg~|tcPxC#_uhu zsiDJ5O@8#qM%;R6P~WBi`VM6mqBT6f_P6VS$M`TEYL>bo&Zs5YUaQFS%=w zr?|#mNE6DixD}@ccGf&l-~btVtN6rVyBfG{qmASBq0W5ARJ|$NAy9qXH%fZAf9nG0 zh-2tNRH_Q@Y^K9^Ez->)%vS-)0fs&yZ_jmXpacmO5`BRRkPFyPDTXqQD%zxUW|N@c z-l9*aMu>s^oG6bwqWE_il+?QK4ivAV=`SJ_FFY&pkIgV+P>m+3&Wu;d7kjGN09%Ma zP}l`|;rHQbMUuSSvL&THACHh8C3JXXj2^;3w{%k1fxE1M_i*UzM=M*nV#HWR5^5c;D=s-%op_r|y^yWS z@*uCJ9xbu^`}ZvjoYK6|5cXJGr$9ekyW`H|detoYBkbqx?U^CVp|~r9-3J{vy0ix` zDfmZAx>B7J{gFM7l9R1QwG;4AC1sNe-rBEbVG#@o3AtDU7R;`@uWvI_ zW)*lu_Xdu~Y6QUf4?z5575O{xScw08Sb_Q{<)D6(OZE8sg>^zn z1v#%L@9eacoNAQ<#y~B8*kpiJVTQV13a)|W763aosISjT%%XDm zXzjKSy%W;OTI>$H2v1vjpWL!Tj{l&6T~l*&54LaB3LZBv68XUj^9SK>%;e^PC`_OP zo_Pisvr(Iq1!A($KM*6dZJ0VOOk#V4&PFMD8uf1;Y`!IYA_Eu{s(ddza=VDv5i9) z9xti=^BpGC7mU=5Nh0HVSE**G6vMQMd>0SP^Bg*Lo9tfJE&pDstF*9QSA zkXq6-Sy`#A4$~Wla^)!%Pod;RbSwIme?tCDQRigI`ZI_8J=?GhkK>^4Cs2Ey>gL+^%RP4q|Pd;-B^ zef<5+VKj?MNZgba)bx+j*h~V%kAaI8xu=x))e1V$7eN`k zkYMFkROANn7nPK(1Y;bnuny-|NC;cGpeiGuzp>Z zZ40^HC|O5Z&?#jP4@F4HBvVTyBJ_pf@o~V9NZGBL1=kRhN0f?h`*sF(Rm;P>s*bF4o9dE0SR*92v;#F7gtm) zpV!4ePY7#iv=40cfoKW-D5XzJOKSpgo`;7A8FXIo0aB+}JCC`n7 zpNC%jX26IAH22k8Hg7Hlbc~3K3R%UvomWO?J$zlnzf`f;i8%$8sSKfN=#f$9?sD6L zXTEy(j^yUSMek1E?`ukBg~;_-M8cn*0~V~HW$Q2zJBdjN|2n^)77P+kRb^WP#8`A&>e|Zh!wO4`m8jcL>33OJ3$o-ie`1B zhyX(EXlioEMw7?^MCu>a`w{Y|V;84sZf@36JIlPdd?=WkAekYkHmLWCg%dr&PJcbU z_sOE=5v6qRUh4M^4Szhrv)51%s;x^p!UH{~xU!NO*j)`Pr0e_lm5hvxVI6Tg&@Ak~ zyjf?EcYZk(g~=8Op}EM;6O|J=YLu=1163G$a%rmBxrZF)irM5EOfft-+9OAfpn=BWdivfc zu0lbsPdvbiEc~zfp2pLF^dypQWW;UP@gfl9QevwG%ExFMw(NJ$Iqblduns|7{Dx`K1pJ-D|BVk8I5T?jQ>pg&#o@SgL5XDgaFK z3JN5%iu_Xuy96!L0BB>A^>jJmcCTt{{SPNK4CN51-_fxtQrgpPaA08G0Fag4fAMRh zK7xx7`mX>VkvR_W3>PM^$e*izu3L{=rycrbuibegnlN%&^? zC-BBlc9yKA^__JrTQQA?x^~^VSRkj@Q(w-@V903n%b~I#N*-rmzhNywk3cx7q_lJ? zp#OqV7aDpfHOlrxe8cw`trQJSO_J6`unWr$uAuvpc%4*D9UT&Rc3=Oyss(o)N}EHC zcOLpCyI|c}3<`Bm>xWbR37>H~S_TFo088Dd(YpB#TXfR&oA|z&#e6OBn8}~berW9R zcR6Yb;8Qsi=RaRS9Ndu%IszLW|2j12N?WkE+)Y{}ZbR)-^48#zp(m0U$CvYLn5jY- z8NMDwj=Jyx*m-b8yrDAAzTQpWCWRG!`R2_g!*EOrIamF`f_8qp#m8y~{~mam`T6V+ zvXH~4kb$Z`hy1-$T3c@-G~E&@3M&D#F7rSC;oLjO-G_oQlw8k1TZ3&CcJUh9;=Pf< zlNYEQ=w20M>;(~c=zJUxQ4TOPh&)~W6oFHH~#5$^tv6zpMp7KthYE6ow|1O<~l^{FipjP1PeGXx%-nl z;9;t4k3?8aV!gZSAnU^QsKFxb36<*Dg}5InD4>}5sRLZWt+(4YEmyqsYXiC?nUWH* zgq|t0a+~Igh3($Qybp;EB;+8$qEt(o5TvFSCmCnjaR=R^e-m}Hm3ZIBXGw)o>lIu^ zqr=|w##R0IwI;wKx)~-*NSXGW`C$x7=-(KjZU$lnnx%%^DUsl@m0|grG$v~jIS|OC z{+}hF$x-~T<|HrQa&tcskMVaah`EmDdVX~`!~UcO;@D|V$K1nGKtIyT#KqSF z00Q@F_}_E(3-}qjfSp#!Kq4l%3udiZ^(|op!>-G&&U%X2X#d$WvcQ|zklK7!o-Qg!e3InrlRFSPGcc~3 z`1^Ms*Y$wb#bVAFi$okmjZ#E_32f}jYBBN#{%FkXV}66yi1-(t1rtJlsP+(wNF)yT zfSjEd33!MFCUfm992cA?4-T6ku2;3^UFh!W@*=h#=mB1eS`17~AP8cO!)?Kof~lpY zKQtYZg@lyGxo?lEaFD>iA)mV`Sm;n-E1HaRAxCHJi);$v72MRKw{Oo{9w#^q*TdTm=*&>tk~CJ1&Lg8k|IcSxAxH zaE`DI_AC_FOTSLyU#O9|&h7=ZD*wpT*kBoMryfqABY>+5}Dp1SQbNPm}*m9NW%5i8WeeO?X;-b1&0#>vViqFE!4RJ?|z5L zi+o%u;!Pws2-U?DlV`W3?fJ4ER={oS z3NNhz4Miot&ZP>*ja~k?!0UOYN3xUf8oEAOM&FcO{Ru+C7P71mc!l?cYQGv&VUt%X zA!*_b{FjKSpF^gI5$(+%#M&GR5%5_gpoS#ce+9S}3Cxm#E~F!{WFdVNlh_kt04V~i znH9wU;g!a2001Isi;#&Bv*e~C{ znWL%@Yn8;cYVOMc?r}X}T54JQpu%(ZHxH%H7&I28 z<3av7orP*A%gMKl@iCVjp8YC`-&xeEZduK5oIwZUQ2wFO1K?(-jmSE!U_Pu*$={Y=nNiNv%VONK=9>j7|51QeRlkchT2e=%c&Dj1lUo|z%$kNoeNo%5xg zIfd&{db&R%I9PXUX_up##{NSJh$|&(rOfH$vXEg!UI-8rk{-g*D<}{E_PGf1x!t`pbEe&_PyeE{Py7E-r+H5*63EsQ-iReVIDQCzG)! zC>K?6dxA5Z2KDi2>QDv}w6|u0nvzQgB8K2ie4%0R40Fgh=bW5w$?|9I29zM#QNXfa zzkXp}C!BA&Aopuu2!OC$^Z#!8-QIz(t7KmjEcV;C9~0_NDH=fEdt zU2V%rso|kIzYb;#tEJ2t{AR2YTQ{=>Pb2nA(`MrN9P#%; z&4-?th*%|9X={hjBzxU3?W0n;6I=6pHX`y_$l3}o|MQ+tY@h7pJdzh}zVEBtk?w3T z_PYA|%Ru_$Ln`L!k+<+3bEMt0@MQDz^D8c}yAFwG=VfQJAlnCMo1BtzSu5ppcIZ&* zqer=QDG(6_qHNkb*>*`JCMC_WPJdd=0<0kMEImEsr0%Y=XZLhM3hDlRE<9;dTiXM3 zf=;{FHZv*H@cCTj#(e!MbTehdi%EjBtIMSDK)*dEF-WO_K-&e~$t0u%6QHE$0Y4x& z^V&JkM~yt>nwrl>@U9FtH{_;0e*8JCrKt(?bi!yIRM7B3i%anSG2eX|+5Pcn2w{!> z`E%*CX-gg3XBaG!t8#*Z$*jez83V*=;JSqVK6B;_T3wZ|G{7c_PLa%xfdS&{%ec7i z?)kDOF2isBx<}Pf+fAeh8>VRCYS+&kcQd?8bC1^E-G3dPi4eM67((th_pW=N`>H`N2}$6Crw zgYAa@%B|!Pg8fbL3JYVv6?FCYzgaE~?-GNA-v0h8AP`)#)2vl7rN?}cGR=2Q_Q)?7 z&zFGunTe<_l!XyPotzf&7#RQ+aHCu=L4X82sO|#Q_krM)5%=$hB1+U=;LHfsBG-9{ z8-a?v*G{Mld@RA;{r#;2O$Z7h{r9V#_Pr4RI>d&$ixPe^_;IX~B^0QcCh%xTh6g52 z-Z(Dqd27do|DGQkULO%2NKtZ|{rl}A0)rFVQ%>0C2Q^$@@)kWjg;kYtBkXKsRlq*% z+W^kuP&@VY^|8(Tl9Dz-*r0$Nj}CS6Jb3T`d;DvG!>^?h;^JNKxe38WuY|&EKR4@6 zA~p#2Q7~!|wA-7S)Xy?MdNPhrP0y}+;j=sytu0m~25-ZWIid3L@d0Hq?JRUBmUHJu z#{-9`?mkSF_Vx2KgMIfrNQdz#+>`QhRoIpGCFDh7VD=pYc-8ROSS8**deo95M{0F8 zecG4+^ux^BMIs#VlcC5aKY8N!-~l&@=FEI#mpQ)ylF|MPJ@S`J*~yk*dOvs{bsL`m zGFyRxkFJ4%8s~kVXqSt>RKvR`(Kmz@AlY(5rMRM>=BK{lN_aTqxDDq!Wpy>{fxrtx z9SZFb6_5fe2e&43JAkufiWohcjO!yn0z_Ei{QAY>`*1iBBIX8}lZa1Zp0jSyf^HW6 z@!Sh0NSYNKS+X6mp7>`)6+u|AsABvZrP=#Mg$!KUBLPMfCk6%j}>ixJil7`K52orun6gTp~acP z{LsxbTaI^d32s_0R0{MFfB4%mh@640ep$+%saxY5_?Z#?q6&9wkNypfk)1pnjm_mq z4~lwBUnG}JP>#6x=K^hIeT??!b$x|3jx!kiVq^IP58d@a^c#pDlsR;0ha8u$1lc)! z32jj1N>FuTw71&#)$u`l2pYPU{~XyvW&Q{p)<6a9NMc*qS{Pv4r()>h1xN^~i<&@D zGU}qELybh?GHPmm=wfilg&~IA8kAh$JS`hqPn{gg`a4 zNW6+N1b&#<*wl-v64W3&s6b^UdN&FzFH(3IK_OpHKBT9o)H#sLZ}AGw5XcYzpZqmM z?2aE_MK9ic{8)&@Gzd(=27|8>&|>6D4`P7%wJ!zo@0UPH8cFw@Sp|()4HFc|6^fqi zkSEXvCaYVd+N)J%Y~&KgetrtZQ5JC!7Vs`B5a&TC>9Ji={@TUoUww4zO@fsHC+E*1 zAh}{JhV^)W(ry!?4BYYo5GoN&HG{xU@FZj%UM8A}?GX-MnA$SMHYbP;Vq@mX*Q*KM zM^$o*+)FcrGDk)>iAG5LfpRl3fHXgNLdEUvQA58TtXjN;1J%{lWh9A$$88ER90z&y z7HsIadFvKG2n9Le0#<=3Dhqm-kDni2b4HtI{K468Sg8|T-i+jQ4=8A6$Oqv9V~*9* zSnt8CE*Y~VzCYY7qFN}3sM%{j|6PIs4K&ETQhhw#rPkm*Bk$Qu&FS_F=+03j3X=I2LUSnX=j`0QWTbJ$nl zJXDG4Au*6I0;YlY+#*LyL8{5jB>78_(h@e6UArh>-`x*BZtQ+jXX5*1HuDcJF6~tO z`*{so582YUrOq0qbH9^>If^4?1f-;Lj)n~dlGGS0>k7cT%pxg84$LQ$%fVKw#6BBA z(%m6=-Le$Rg{G#(&dxqOJ2gbCB`EZW1v;eD+Cc6gi8^FscW+qD2l|ezG>Nq#U_|H| z_^Fmg0~L99c#Pl#(IdEXBI2WM4>j$k=kvUQ!$3$-2?d*+aDtd;6~Yc>&U#1oxNlfF z-y|Y6_4R{fE_~&MR)%@KU8<_fIyb%)4Lxw?z=qYB&L!ytQngsN8w5a9{$hy+6siV&KK^`deh)ppD@b^&ZStc1Y`!<8Dp zOmH)V|0_e+WDT91B+1z+vz;XOZ1FBCaBiw-t_%*y-|gWqc)?qbS&T&o-JZAy@x(!SwT}q9L3zt6`yHL+uS` zuz{n-7opxYG!#w_9wEVOh-pNUM%vpH1!isI=nfcudB>uayuPkkg?71;F$u8DM3<{z1|9MD#Zq zNyY1MV37i%Lm-1Vqi9PH^yi)_Rzs;E^Bz!7>lzxo0Tm%%VP>VaI&m4a=iwO%0vv7021H1yRISNJL z8H#NN^t*?tsnrNP>LN-+ba@#6sF|hlSb#ez1EBhDk#W1X-rRu^4GUY_YEmOU{XoqmYmlq)>;Aq)1hq1!2q4Tl^ z?(PaG%AAO>njpzS{swA)Ce9xb^;JfLOb90Z()I6`$iLg;?;yD$N;!?0O7^NH zpM(X*KE`PgyVmKPP?%@8y*)sC-QQ!OfpW+TeXK<}_lmp1keTa^Vs-cLA zh@@LoDXnjQo}+N27k#ucjH~T*Q9*(0vy6udS1t zYMi&ctrOim4;z1#qSTp|`m7|`Y=E*67}6t#TK=SsU|NA56CyYyWF5>r-69VK)I)Lr z5?pg=+`kP4zw?u69sJsF!@WDPu)S~HVnL=_e5?&YO5hyW6&AtON=h<5cn-`IUH~X} zxB%>BR_v&3WNa7D(00rg!Hc)IPH+RSprK-9%Ns@gu=NpJXe7i6g>~D5<?IwV!_bk%cj=oKYH8>E^8^nZ?>gdac)~nD|YJ5T14## zC2XGst0IFdI5!0&b|SD^hapvE>8l;*1w$De3QfEY7=N4CjCNMc`=ynlafXool?eDq%`3I?b36@H=~ zfgaX<82>!t;^IPy5mP#F>5@$0->)2;xMF~lw_kUpJb7a0B(iN=Dodp35E9b~T3djN z_*MtXzEDVm^t%c>*qa=S^XA4DiWfKwiFlKtJ?Hk{&$AL`qus(#(4cVRnF{+Ak#oxM zUBN9Lw=6NXK+du2`|+c!ygcD!CQKd*<<7x}nRCx-70GxW8J@;RJAAx(>n@xbWvD2f zr^FlnM03uAi|=Iq-50qp6R4kP4SmhKLk+fn6QupwlFmbb3EFrsR7%49fU8t?(_h*O zV?zGouooT$jju9v0u_LG_!}lgN22QoB&^>je9QMZcTSY#yhyMCEeqA!B*Z@TmuThP z`weW_@+rs$6%Xw$3qBpbi<}i>)tz;oiix z2M-ufK?|#`{)4jL+04nx=NAxQMos_};`zjxGsly(QV6xdMhK`d19;kPY|KM?510)i z^T>%;JKss*SV>D;3i(p=#EEL>E$rBn8pg(*J+!+a5c#9;0!y~Je*#*g)nO;nn=LFPIk;OkzUbR`{$FPwiqqbzhi=wTUvG-ZhVFu>Z|8d}>9Y}* zu`o9;!x=hgX}uqC>v~{eorw{4Kd~}v>guk#V@4OPiGWS4Z!vHhCroq*Mpo-#N^S~~ z{o5c?ZAG3%l_Q~RdKL5H+FXZTR#7qtd7nbut%j0;vqyqRFG3%2!pzLq&!5XFkh0%d z8)Sl0b_DUo>J@JWXVuxn=Fx2V_p^-#zL7n3_sm3ZczY(T?-ly> zJA7tvB-ocR_=tg|m}92H;q|d09Kr*gpY0x@{E5#478#H=M52$Nk+%Z_SIWWQ>iqKj z0N^`ri_7(UVk8?y5@%VBAv<&P)X9^>hV0)>$!swSblS-7oNX{mO+lZ`;HMruemwHy zhYuMbg*MCRFb7TNRcVVe-9p5gPtR>je^JV2{upWyUY{8D8bJvNGJiyG_y`HVmg`4v zZyCvI{j`KFJoY2K=qdDTF`QXxVPaA&csS}6uuQK0UGBM)!nLgrEFGuD&akXoSAiqO zYSDM@ASc8DLl@1K<7jFV%5H1(w@YCmVx$oRHoiW1=uqC5mpGK|0}_+Dy{y9ejXy0v zCgcAx);iJo_(UXr1gy1F_q~=rt?go1v**j*jN(+?W-#*ipD_K=H}k1UXU$*%gP6F<+6#C+RhaWF!=Y zo-vJpgC9myRryPhuHKT&Cla!Yw-|(iDp2(b@}A6udc(5oJOyA5sm}~37w1?iBOQxV zEeaeos5Ep{{@ospIUSjIgKCk9*`a~997ZJ2+#(YJ7RhgsgWrhSh*+c~uuOmV$)-p7f&3qX_I?d#B!i8+ky)m?u- z2Wx~l2pd8rW5UT_2oIX|)y29+?op3C4kHxCoH3EB3k3W# zW5oVMlEI6>xuGcACcrpuk;^C~L9t==O47;D3lH8EC+E%K%#p$K3LZ2|ycWV97;nL3 zE-Drj`3jh>5f2`O!5Ae!j!9E;6w34GRx!)?4!!h_k z#`me}TO}10zR)=qZ%zJaiuOfdc^uM`$9N{R^YOROpJNbV}*x1kRh^RLiL|2 z{%VyLOdg*3bU}(2ng}9P zc`ZaE21vzzA+$4?MYt5|Q%q{=lyY<;&Tv6J#Nb6B{A)6~33Nb~1|F;NMTLZKC`a`) zhWfN-Fy=Lljcf16r>8S!>b6@j^$rZQo2G`OG|h+D$?9U@lJ&vvAX!0@QKX|Il9F}u z+V5fjC3z1{kw_tQ1ae|zMusR3XvNV#H-}csEede=$*3tbP^7TRkaQ)-9>TnckBwb| zbwJLUf|D+Og$WAI_MMSI+FL7t!*X|RK}wDUc}M$DkJ(K?#v{~y2xW!_3!l4Z)q0B? z@bxiY2NjhU$3KE}5%F&N?{CvHXFh!&-}EVZf1)zJ_ulS<*aFyVxffvGK((&NUBZrm zW!BMp45$7zBpnez#X=<_dj%?kD3~Xi4ZuUg!8_e)ipmeFFns2RAM8a5CUG(_L^n4# z$e{rMo#4VFhGt0%VoL%Q-afJIQM4v-+A9&He3dU_R!^Ag-saurDW=c=smMA1!$W;SGV1J zlnm^Oc8_eP4sM} z);^j2HGA(WE-p?ESjGS+c}t*Jh)__$S3CGXem$-N!PI`8ZL%}W3!a;N66zm-DtT=F z3|v=WDIpO>rY-TQm{DTHUH)+5`PB-Oj}|b6JTY)59C1pH%0ZS-VDn}g42EJ5!n#F* zgPk2ChO5xcP{>u%bOfNQkvdFA=MxrocvF_2!=57y`)sxZ!1>sX;^}<2_i94+6*df@ z8;w}*!->9VXziW#I9mr+b4f?XgH?8WL)b1O$!(4%%xv{erj1;cw`@H)s;IEoQexYpLzg(3TvHRsU&UL4{+ z>=Fhcy&Z$3SV1JOjOgL=6m41xp{AvG$T3_E4bQ4PUylea$Q_rcfr3j&42%>8)MjM% zc7Upe(9qL@4GW%| zehFI{npXyNMiN-SocwJ$=k1_ruI-Q3h``{gguV{#k@&1uwzlRts18fg8*GD|-9n~< zU~7%0*|0XZUQKwoyQaZ!L)O|?I0pUwRwKiM=;hb0T{{Ofi~+xebI9BGUogvL!$tbz z(xDb&`lIw^{+pBE6MEM{jz&F#;zf!VYfVC8;_g@t3Izuji zrxgph;0QLq7cd@z`outlk@P==y$4v&`~Uy{wsWlPj8NvWvm%6wa>$kyBAl{E8HuFG zD%pFMb)vGeXB5YXjFOHdt3$}1^}F4x^Zos<-}N7#>s;6O^Zgv^{eHck$nKC}_)P*|y%KfhX3 z{JX`R{)!Vha`Y%PjS*Vj#_Qd^d!8Ac)jIF#Z{#>G_{b-F4&QVHZb6xq)icZ()P60& zGO$fDlIt7-osd1gkwx-_%Cn=7l)uz&?oSg)x#TvDN_6#_`U=S{^m(-*T~3x+V7o508m5un|z~cNvH?zpjT!IXQ&s-|)qV~Q}3<+JO@;PwD z-~)2l)o0?cy%YzSmhk$ptJk)TzzTW8=2*-+8t_jGU)kjyZw3`HXk}z&hBtXk(9t~T zjFi!zD$DGz>?!0Nc)dqZ@TxAo;rPBBPy?#$356|Kz{!@W=kEm6T5M;IePo@Nb#Tc6 z2*s&Q_#C9ltND)g^(pDr{`7)pxJ#OC=$__x zV8MdUOS|>!aH4i-m0y%-L`vbY)AmHMK zX(|Q00P;hCh7HT8=H3>~n$6$3b=cuot+sv%MYt4LZEPSlMa$kcgS+&N zH`gcL#PB)v;ZWZb4+iG(tWYz$YS90B6!@h^5N`SdVVkrqiTuow`%QQ0SgOv7(iEE4Wttkd_Op zsr64?h>B>?ph{nc?dmgSM^~01+I{@f%G2T^q;%sSP{qj!6N~rWde>xkyL}eLz2aA; z2GPudhoBkwjdhLwN3=DFG8FeS8*>`(z^$lO#yC&f88fGa`=q$M!qRJ(jDp;cC~FiP zVKM58@!4+XJz3Myw1=4#6(cztfTHHCD_N5(omI}B$0JK4ePK(@a=(%D{NR789QKou z+0)J;xm?hh9!Op3O^QyMG^wh!_j;!TFQ14+#pYH3@H84icW~8}w;pWd%5Ag=Z^f;z zh0o@$0xF8Nzt=@xP&{ur_2*n{3IhN&O%?X;{e^8uhL0R+4pJ*3W=q={(-SX6|Igih zd;Pd4SBrWL`E4ZC{`QcNJ7z7*AT61bdo?*k5b?hlR?CIEO?jb(TK;pLV_RnX(*%Yn z{WGZ@Fl7Y<` zS~%}Zmsh(*`&|}C3Q>-wQl15OkjfWS8-de}g|*tBpn#y6sCnQ$utMmNyt=Ucun7|y zp3Cs}=6kCdTmXjL4+=KKl^$9chtAE(z z=g$k%8nU}l^`>I6>q1`ylu_8X*4#9-ThE@QI1nkN?8cAZAJZNq zusBq>Wc<~}05`H$fzI8&b<1$VIebb_-;VPLbFXRuoQyb_&3Q1%DGmNoP(+>>j>?SN z*cSW>mmZF zXEJTx*z>kdJLD1D?T1lW@>kpbvQ}0Z9k5)6iEdLa6}<>y#xa=a<%C>q^APJ9W4=Xr#(yfXnXBrz@kj~T%R!$#JnU%zrF(+JhM zT5{&fo|X*kKtc#1{boV(a$eo66?q$TInQP>`a_~%BJRBPL~dnpvoNuuNm?2mNto+{ z=SPRldR9L07hNr3vz=IwNSq27l*>vNs-QFtT%qAJDAWl>^oF)G0M8_J(&PZ$UD=X; zgX`GX+wZwNm;{9I%)3huQc`{cYr)`x$Q~#Vnb~>pN$I#i{~Et@|CgNT z=GbPYJ;1;w9_>PgMBuigM~-YiaG(TPtAW2L!g<&|-KWG_G;P|^(ecLr z{c&z^aU(DzGd|<)578VOHgww8FDtd{^lj4*#H98_cVR$9F%M)*`YY;ssImgC#VPV{ zENpiJ*n=`mS_h7GkwFk4p+oca9l)f3{J1pEUSoujjaAjWv*at> zvx?9V&Ev+TnSSK;su2axu?G9yPv3_PDqXg00WR~8A3cP*K&p!UwygS_;gRvVydCAox>u>9{lv%Den$ z0;JmE?gRX6`^lQ;txc;iB>`5bIqBu>xXfur^AkwwOe7xFME0+@KKXuHzg^O?hTEsX zfCK~2dbgQzfId-giR}Hv=h}->p9ctU89`SqZ(8Qb?H9fEMHQKN>z ze8t|rZ*?2I>vZ1gM}s2wrbMP*=uGQmrOKQW@ku<%rBr6R7Sjd+xlz9j)#^% z{)M`j7xp4N7iucL!l59gI~>rPIcfJv_Or6GY8SN@{p6%Bx$v4-AXtIeD1~ryx&jk@ zZM^tMH019=_d9i@Ya`h`!|E6v&y9}u_193%9v zh5$Q=Nu8+xA~K_=)LyYi$0w>q#b%D+QkS%7PqIBrk*4WJM;1vDNT0U$(0bgZ6AD{l zt>gTBvw9<1o{!ygn}*PY-y1dRO#U@3_ySO=ktm40*Vzs3&2I!im-kjyd3w@sjThsa z8x?%V<6+XRu>1Kzxf+&4kxfw>GX;@r(Iqz!mJG;fY^*Fy~TWURs+LwVY~=x zNiTwi=nFS@NVPdb^T5mWPsj)SRT|TUX-3Su+xFEZNq>9DOCu+gp4b`fuD-5}8vI`G zb(c@At>Z9v>W{CPt~~L{FIsG=abj0T`&wnN@&|2glHOGC4-QC5JM~ZC%TzX41snUj zd#8MS5z}jTZD=N1@%emy0RM^|xkpe#cVq!_hRZ(KtKQS+0nJE_=~(0O%_3O|n>yDp z*0FA=LGAD6cIBU*0|tEAH?4ci!gUYK8r<=ci63@>#JcOQp{(QWRJ_?L<5^$e^2c9J z9OddeF|Ng<$=!$6a=DWLEo-i*I{C# zTUQBeCshyQ;_+#Nt9ae>m}^?u>)sj2I0ch)@X6tvtG~ykeS91G#4e>u&zUnva{=$) zj~diu>F(%FpMStm_I*%P7@3t0LsDrH*JWbTKT`L_Aj+F zuQnv{Xdb~AKc9uJ*` z%qEmLGj?<9Z&ypXHY#z(YwE>OD;(^qKOQb2GH}V*?o+p{SaIRZ#*&-Hg$4A#)2PIz zni-!OW(Q$`82fXO2QrqgGonHLXMft=|3enLFqnhcAQ61_>R~~6r#st!<|0bvl0~KrnXkJGe1}sbjosY%J7({tNBL6 z{20&uo?e%`IwVh#4OZb07gfYnIKX1;O`m%qwZX4USY17HxJ|K4O851xH zROm6FktaIV0ptUEOb!@Gi}=Pij9#K*OzXC7@7P6#4jJd>_W0uFm;q@iD#0d(*P_0C z6X)X^+eSuldyd@AcKq6|cNU%%E^ zdbQ+{BV8aSOTJA?B8-CZ6Rf>g1>K9k6;`*v7Uon1t{L|q7quP6?dRRvo7$FfEsiKl zkqlxeP`RezACt2Ux#*SZ|qCB z1~1&m);2oGyQ+V1b_C@cT+nd@pKl(WQSy{t&N2%c)aAt{qM2NZLnpJ9|B~E7CAi0G z!bl{OqlHw{3C)C3y?_CH(vDy}rEd~^k*d*V7-1M+#uFq{aQMJ2+|=OU@cs*+xBv*N zwVOGQM}msYfF8hQnWSEP!VB`NBoLK3?B&WEs2HQ6EHY6Sh2XO$kEauh0A+|9 zYBm;xZSJp6%oFN&p1fI(Pk&@3C`f*rH0f={DD%pBuX&3bRHCv=)TV*O3GpGVAlYt* zV}TX&eVjbGv26m&6afGk(&r$x$e9a@m69IV=GNS;Q`I2=wif7B_VC&KT+0Vq)ZTK~C~{R@%YAYA2cP%YH;VE;ECJ8547HyA<1>j1J=L{ zssN57S^Fr)7Wnzu?zz`7w|j7?>#{6$lFyGS*1taXRcVGWYv%4rY1lwlpn^aE3n9SW zrjd>{N3FQ_Occ}L1NR4(IYA*rNojB)$fSMy_J(s!JjX&mb6dmSTh0bgpwaRj((J*_ zo8i|AHjDcMepW6Xhgwp|4{R8NrZf`lr8p|Fx9=TFkx?4J`R%Y!DuEja9E<^0dQ6eW4BV%)1L4<(NaRUBC+P>|Y_uYyhv{10Bj7+GqQ+xV+ zFPl>PQ+;keb?zcA;RV@2`W3Pz^jT%U^36V;;JKggiwOwTrOSrZ;-qJh{0OPThoR!|g4 zYU{P;bcdZ`_wQ-SmV#jg(jdl^_aYyIhydgjnhnTtVnLxKKd<`&CHy_+fkr$AM-|e` z)!*eqKaUYqyBAr&^hLoy-WZI`h&qEr^+WKP@@z$8#ny-?V}y}xGO|E`4E{6m$-nFo z*z;(p8`@WIw8WBZ(L|sRK~>sh83zFxKAdJJ<_t~!vU}G_t8N3_-Y)Hj*+fPmmAFcZ zhbw)8xvIgXk(tf6^lYDNT+G_eD7vC7NI1u6u+-o8rays36x9WHr$Nys4D1qoOc@Gp zgpp`F=rkx`^ivpS>8nnjA}tmu@vav7>FJwnabfPq#Wbc4+(F)T24EJETj< z4W|gx=XRGq4mZt#S6=YcEGSOBk@YLvgR}*Q>Mu`OaM?+xR=4L?J2(QR0*L0+gkAE- z$?uT;QBKBL`zC)!WOvug5j!O;|BkCyjO^X%e6lotE#(4iSoHkZngH zou5y7wwo6dKo=;d5<{!_H=Z>&n$mmeMGXd)V2q=A17oA(kIMFZ;{(B~5jRL-;0&05 zo?kxPzyG#DX-4Mp%K0D{s(74?pNnhG|?m}_JugT55DUI3!6X)?g_Y;r&*$o|yhTRYcEwYl!NNoa3 zZQE?4+lTLe+CO3KwP%$-6)TwE8;7s+FUK#$Y`&ThRq^Yb+LwW{FAz@z>I`J1MJq6w zsUv@ehqWcZs3VFK<(#ADrKUdSU8AO+xmnz6*oo`VqFmqyDc3&?EjgguTR;PAx_ zO9KP%wVs}1tO?t<&wYvy2jnSYqQds?A5~_te?AxX*LeQ*Ysw_~TsR4R^SKaa*5mMC zO4;?uE2=afQ~WB3 zzZ%y$`!ItXXeoqP9219voR(PH)Y0{?FPPYYn$VeV!cz09H2 z-1l&Ze+GBPaB>QHaU>&ATRnV>Hu6p6a~@3PA4IiWF+>8hTAtby5MY0Jwim7?gPwim zAFEcas$_Wn?Ag87U+YG1{C_m@+<5b&h3W0HpYN8hT={Q9Bxj3z)lKWx#roTfICXL3 z+N|yi0|J^;u{aGImbH5AxUrLlX1ISq0#wQHnL&x}RjXi(g6iD(Yg1yM*`)pQS-2=I z!`d@Gz1TRbv^b*_^miK&Z9F8*`S9>OhW2SCxftX+0$PgtTEZlK3rOArcEtmTc@x8! zNt5Ep_PD{796iJRX(bA#<~w>_q4Bsn;PfBhr!?UE%Y=FMMXbbQCW`MXQkTXdrT zPN&`LPjzto{aC*v-5qaCy->THWx;EOCfjx_U9`MiN83T8h8Hn$S^wf!NWzI)doRt4 zKL2If&}oYUqT76_RQhJ}w3{FHHa9p9n~-qMC)={|xU8E1>?ZTZ4DS@5?0n`e)G02aGugGJG1rRwArEUK{ zRvuoNeo!|p1X)Qq=+Jh@o;?A&5jht)Z)F8ibt!;}VKtPNh(w-Q)%jKhkdYtai)tvL z_r?i?3rY)#1`Kz7aXHIRoJgfty76f3!i8P@&M_dTqmxtA?Zo!DXMEa@S+aZgm{r%% zkK{AJd-$Bn1}GzKq*KEResM1>D;Il4$zzy@TENnJcfy&B%$9WraA6@^+)nI3%a%va z&8hZCyoCly@kedBBo3W}(#ZF9+UJv&_mZ6_eVC*#hb#pr#au(q7y(Wz(BU~D-kj@- zuRD42`?>Ih!6`MJv5Ag-pIu~4u1Vb|1l9$Ef#_fiu6Q&{Ra+kG*)YDxCr04GI!cm7 zKW;%ktl$#nKg@?9;OJfsF&OT;GQrK=9XP`Ny-m-J?`F0WY)|tK3wD|PaKXfn>W8ZI z_VZaBFXv6h9r<~0=`El74M?Kdv2R~dbj$>@`u>_##34k8@sLK@J~wvJJW&tOWg8Wo z-{s-ho7uk<`Xui!YJMmwB=YFKXp)N=9IfNBJ&NDB`l(fR1yPXr4;5ESx8fp&J-JjJ z);5WFyFBiNZM|}>+8qDjbG3FO%B$NDlU=Uu%RP|XZRo7<&o85PhFt*X+49Q4?hn3> zAOn7mAUt~i;*iX`pFx!w=3X4um!|ltXTSU!X(J~XP{i?|_=a3Xtfzbiz&}?W$jVAH zGBi=BvC+Pw)Du*33Chq0ikWhCk05qN*4nrYN?vbK2s= zV+zYf%bPDql`u#sUuDijstID@nmnq%u7y$&-lUvM`M7`O0gs2}RbMZ<3&UHEy*7eg zVH7{dIo8b74(&@@{^w0iN7#h;E@qFM2ug5gW5`9)3QTlg<>gD_UNmPVtX;qU3f~mx zyDRIbxZz>s2wOkT>=1rTr#BJ-~^U68n0S|tCcz9zRvt3qg+jA(#(f%}h z@#T@9$y{&BhQYDkt;zPTVZS$QIEvEZPaUA`sx9YRMzX68QBGKZD0`mnQ5OjViY`Jn zEp_L5Znk`nAn7pjl!J)zno&{7o{3rY0dkyLDYit#xEdhoP zP1~UREO2eakYhboKI{K&B}P&tz8fIVK={YNCO52K|BpkD!tzbcKAAE=*E<#EAbODX zG{G|Kf>uqK-sX0EY{F*eo?F|Ekc<4zty?ZEW7%y1p)KI2u0~OD|2mf4YMF(eDirvXK?0rA3l6ro7SzH`gXka)T&*~#wpQNv=SYP)HXH} z_e(UwlT&ZcMuRM#2(q(UOq9EX#6q2THSiRLfw5F@I|jLS9BfbhhpEX3H#xs|ClshkrARs!fw5GZ=4m-i1;NmyaT5%%}rBWbl|6Xfe@&N2kneC^x-L~ z=ArE+PonHr+XKX@gOEXXTmk-643t5~gA!B4%&>BZn@}v;_suvmviGKHj zU423rs{maTiA>d9K!u=4`5TX_<=&a;{n$z{o`Eue@P?TmU4~~hs{!&fgx=9SUZAdg z*4vhIYh47;qM`5u`b{X^b~CzeElGKwC{8T^-vz!RiJ?VGv#Mqm8pxqS2UUf(Um^qi zI~L3U(;tFX26>%FK=#mo-UbAL$|V`CwTzWE=X^SDvTQ@1-i|ZEz1>qB{{QDQVY5kXNzI2P`8Z}sa9Hjp2`lS zAkOx$gXOvU@@A-n_&`1UE@i<{E?KzUs=!A@fGN-+k@Jlg$WZ%(D-5P)^2FmFLxWVQhnzO%h~=+K!hU9W~^I&tnx zTMg(e`v(mgpXU~ZiWKnJo6X4c2Aa@(kKMcLfRi&MuK>pr47Gx%`PC7+{xs5pV_{fy65aNCS~;K9KOu&v)fLtR5@{%}^#05a4d%7Z9-tU21$ZhiHl`F*!7Yo>iLXH&lP0#KY z)x;*N3%m*?27pOwVOC( zf6srEm223(Z{K1`x4_2yxZs|~(F{c+q@W+KTD_3jq&mzLp$v)zOlEJGefz*Znfdv3 zB_t~O40P!LZaqVu9O4!AX}`medqS@80fjP%MUV|3^d zsbyuJPgtmo3cGfhHEML=!qSHneOJ9$93}p!Dkmgaj4&8=>eN9Qv2(*;4q?1mTOQ-E zv)+q2SGirgo&A$aEeM@W0YD*xqG7LyQC=+yEs9DDd-=-PR|D#wo|%~+#sgDIeBvMdr#6+ zS-@*oFN)|O?gbe7-heBo8|AJu^ELbgX}d&SrCwZso^pFW%cAbKz#ph=CmlMzfrBe> zi+N|w6M)n}_E6Xdt(-X%#(9akqJz195foejG%<$WeXjugxh-G`_AybxnFE{^y-s*%f!;up0k`At#*_9!_V|$dXr73PQFj4 zMRdTP8ImE9T-*y<;%-YepPRdX*RDbo!}a(>uu(E|u=%&e$!kDw$L-Oh_OEf2_{d&F z8&WtB44|&MUO64e{8fynHiHIj2=$-!Y37^$zn_MYI}xva(68 zQvrY!TAt#*eebw!azxV|Ty9vz5(`wSg{z;de=X}|5Zw!9TDE8P&}X@~w(-79jbMbU z41iXrm32Q|&?f0bLd0>n?oJ#g4I4ImO!ZUB`m2Ga{|QA`en>>eVZZm`kpN+6@Nx~~ zj`hm@@yAl12JQLvpvL5cvYc{BD|TRQm2YC(c{Rl>(i$U%~${+KDV|l9X~Aw z6=p0ZRMdbsa-OM0zg&K68bvtF>Un_b%nL=TyD+tGrTZU6&7MYRFarK56`&|Kb0bM( zL1lr3I`y4j)+RKsj!q^2yn+Zw={$&RP)342N1srnu~g8MYh8G=gop7$b7H@Ni(7QG zFte-QJ2y<=rur#Tn{VB{dkGn=%jnUUJ!{!4DmQ!1AMYSuB?;mg%Phy-Jp*ie<^7wD z&CBPlicMjpKJxL?qw3l?gn6|*+>Z(bETk0TM>*m7Z8MQnA*s(@O=WT~H}}5iaa1@0 z<-F8i-875qkXRQ*l)*K!tD{l1A{5eWDtr|@q-{om0t)TMeomQ z2Ld;#pC}(BG|@!_R}3KT3gM_sSJqa7MNzXYCV8L2Ga}{l)6`U7CAfK8Z+kV+-#9;~ zARmCB!ZdvH^6<&J2S!QXCs#48w{tAZty%6X4DGKB7%C+l+q`#KJ@i?wq%eA;5`hou zyrkb}w-P_LdYPx~;clgElJe($f|eSn2C%9LMsyMzGZq`0_h&DwF6PL*`nnHdMr9!I z@HOJ76xUt&N2uHV^m<+kDxBxZv zd>70Lli8W^o$~fog*9w%-v1Ly69(=zvHtqFfWC;sQZyzPVRtlS*_qMSoYOCXA;8m% zuo$Fd;r`S|a`-)OdyV8E%p?m+BPZnU1?vTHFfuz3j+I?JJzGbMyH>4QV7wI|WtfZ8 z5aCHN3e$}vmKeW}$z5GneBcIhG6+Sys~KmIDovfQUev|KdfOEEY>DF@>1BqUo|zBU zU&=5^Yt;S_5w7+p$s+fIz2Al%cm%3vuH^HaO!9H(e8p4m$1dE5%vfI!G!6*0h(d?a zWboT)KC(}|4@bGw77L>arHyo*K%J&^6%tG=2}B;!$HB9GZ@swb3p=AKmPEIe<(Y) zKQJ~*?d9%Is~WELZ6M#K zhOs2w7zS=MJ3B0y?im!m2t@}SzxzAf0?MY9h}Xr1@^wS2YYxY4xyZISbFA~EL|!Ko z(TrwE4mbm&5AFK=e+dE9)0@nW-2GB1qv*Q znW(7g_d(tY>Df}Tv-%52B zhn!u*mxTLHL)(LVa?R@IP+4n|=SPqcg=$CEG__MW&Ja?FZy@6tp})+ze-#-Y{?}g@ zL3}g}`u7m(*I+bSJaknaTzxY?#XrJXCdgy8r2;zX>AgO_?DXPpAOF8A+gL3I+twz?+Sxs4q=lG~ZcrHkm*LZ6r}_9z2oN1%&DOo2Y%aB>qbTKG*^Y(Lp4s7=524E+S?&9dpbQ6Hz>++-w zPinUg_YmNG5ZT>SW@%v3;1Y&+FZ!Dy=f(`pO<9Qe5={ZCobs*%2u)|sENHI(4Z@`H z^bGT$RwVTV?(@|SEndm|=m1yGT3pES`7{fX#VWh4I&uuTj}_HQIUM@E;y(ahnxnCq ztX|+xL0KpvigUn&FvpKzH$5Rf&=w7h?m8@#HobeV(1B-@RTE1PB5B=sEZ$iDU9Vxo zO7bm%*IU(_G_&2XrEgBrvvJQW*w5VD{N2mjH6;cFSxOq)52L6`%nL;1t57n z?ZA;8tV(IxaYG%S_M#+b4CX2WM}Z7Z)V++;y1)>Qm;cr-$qndGqz{o%$V{a0kg^lL zS8+yw%TrAcbf#rYMa?JDj4n^qny5aNR&M?dN4a7(Eft~h1!C2kVx8CZYvf)VHco^9 zR6^|n73lkfBJrVDq9}SE^?QtobgF_+DP;JVs)l)8+N;Y<^0DG87dWtGA3YqUH=W32 zEE53GYU6Q5t$YwG$xII1ceF1BWN=Ay&@fGkB~o8=70LhkD>}PId82}f1XTmF*MLI9 z+$dLZqpXR>W~M{Ys7Sh`cq#(KFG4b5X}sat5JAj@ml4k#dE%UWDaTLiQxGO5@SL@c zy88m43rS4smZ+E#QsW%k?&PxT`uAy|uI;ElQR=hy=aYnA_tCv2VdRasz0};yms0=y5%G<2Xj)*&?gn3T0Si08E~$UmJ{&Gfu)n=d#=GGE@;Lo z6rt{G-L`EASDvznkXvyba+^Pf)&$Qa0%F=6lh8tvFd}BsfCY#EKno^5Xo{TPT~7Tm zGQfsguunsdUeU!kaq`kECz~$r%ZaT;ffGm?-sn4bR`D^83;|Mt$OMErPmr?W5pF+w zsfE23$tMG93WDq|fl7UH_*z2zI?vl13fjke!OY3wQ6XHD4 zrAx$)WIJF=qM+i^x=3=7rj#kU^&DddwGwd<_UV0RF@WMluy%g79muC3I*54vIc|l4 zFpNC7<3YdQqm;G#jk>jj#%EyRFfLuXQZ8Fhb7CFY2m|dYD5Io8DLl%eW6EKSzjPq{-cODzV z`5Zy~sQP4nP9(R;#)YeLJ_h+ObeiloMsxT}N=BC1tATdENk6e?+guw0$hrA7lNJLD zsLaw=Zhic2#v83Lmyb{M0;_xRl8u)7`zR1q&CzWZ^1Kt;yv)+eiNrN=7HcPR>e1iK z&v`LEVI;YTSLXXG2U8wtcjo3rgV>a3Bg=V~cgBnU)CFs;-Z%$L=nRR_Eng z9h~@&mG{Tn_Rg^@D)WdXDwe4PdB!x;fZ$f2UO#BArUtunv@Eyf%il{MvlQ`Ld^;IA zxQ-?h=2o@M)Pf2ypr1-OxM;QJII`v`Y88GZb1uaM0@|M!JdaFY&V?ST01WHzFKa@! zxDb27FSlaV$8rfl-RV1qry0lpi*jBTBTdv``F(ktB7-ic$cZ2vsi9jmVFAq~v{?y? z44^XcSsBxv534b3SFIFKf?H%e9I*U%{(*ZaVLgB&gLQU+Zd&eZC#RUUZ%_NV-`P#! zbg)s{3@dNz>MY?)m@cWf3$gEzPxC4>Dsx#o__Ee_0ubTjw>|Z1!GlLA8ALi%pYyS_ z{8~Y_4q;tc9b}pv9C`USX>B>6UlL-ghRFYjE1@np7@}brHAqjHi8+0?PXn%TKmo_O z6VaQxENj{3T_(c^H2e7YsZ%ux^`e^8l!dw3zh+QAJf<=^V0z}x;ixEJq81#bb!XYG zX%WbyO*(glmLC__vibLs4sckXQO$l+QqwC97AL6K4q1`P3@D!{78~1e`$mEj#x8yT%_Ar6^iT1*AAaVbqo zJrepm^|EFdDBD6k3t?AJtood?JKU*s{7t#iH3@|G?cVWL1qLiMqz@J8^wE1|NmZ9$ ziAJs6ynUmgCs$9LMUDDCf`yPbd6_swT^P>x-v^L!(3q4^VW*;RG#hDS%W;(tSdxEA z7l`@lRbW)u&YklC7CA#st~^uX7sC}0o;MDv+UEWJLeBP`Bl;P+$8x`D$6@-H{I3_Kk3o+(9eitQ@F9T zs|3PX0~*A7Zx^nSbJPp4ZocPO;XUZ5>!u~^jbQG zp{Ruo`-h!5IcRu7@`qS*E-HW8@CyXDzJ}9V%-)Mx7Xo?O~q$p~1EdqJvzZ)XqSC4+3a_$ftmAK+NV;|NH zZ3#wwsC)ybrZl)*)-hW<_}m0R1cP)#^`)Oe5K)iMZ~0erB?G~;LgLV=M6!ii41CVy zBqdf~O+iw_&*$@4o|prmhrIHAL>uH1(#L%G^l8HL(k+q)OuM=6pMU;AdHV9@70#3x z)CGf}ZC9;XGn$@l~rkKVRKaFBSHA!jXv)!_Evoy1xznQ*=dcM>ERC z4@P)!fm9XK-TU@kMMfCMc_AFf-(ere%3%@?r$l8_Z5Q6&DPOdSD|OR;Ufg~NpF^*? zmPXNk2d^%@>}dBveaWA~*>@gg`b9hQ+e4~%n-;fj_?ngo#mB9BINLKkE8$RQo)b9z z?*03(^FC@{>$%11vY{zAP@M`(9{^w_DovuxLlPd|r&zzB`q|IDIw4nw)mgrf=V})K=itBB`lt@wNKvpn*tjG`BcqYXQTuDwg55U(99wcezGMV!Kc_0nKFfnCuIa0P|NR7>{Kg}vX>{G_+^ULpM>KnH zPU-kEl=+$sE<{0{0Nv7%XMYwTU*cvOPhJJ)pFd_ypRR!^Q@HTFe|<^-OUh?Z>p;lp z{LRVRn)DxjdZsVhQ?pvN3eqb#ips{ALZTn2iR$v~S*MR3YcsrBvr!JK9(wTxxYt?@ z3`ft&X(-{#x+cTdUQY(7T!7zCQ#njU?Of>c5W2G=-!$dvw6ko|9)AXd-No{8 zGU*3zHalWThw>-bgr2g;KErMNvH9&ec`8LqeG2=ip zp7ha|O=>@mn=+E^1ylDi=F1Nl?p7z9p>3&snFH+;c8K8N_OkNi4$dlWFtHd}5V>1I z{j`s#-~W5OQ2u;tT80jFU6u+$JMhq`qEDYb)euhnvpJx(LlKNakG@wux=Uv(ym+ii zb5*Qx_{T{cX5vcyL3K%tVk^?y_gnSwDa(MTi$-#EJwe%u2^}YX^`( zOHS^j8P*?H;(;Od&trSM1vQZUu^V;%fM!<)b|cN8ApC5vdfsW(7qSm1j0SJrwyo6T zxZyStpcR}zQMXT0Qw6Tg{C|}RXYLNTJDxfX>DQXmn>sqoUQHA~>m1K;F}NtjDwdaS zdGInunLz(vbzjIJg6+iktJCC#M$Y*$9ZG9Yr>@F_j_eTd*6rQQ{x1oJ9(L%pJKkT_Ji-3vOR`D@qSukvi1BbZoVP*`)gaF6=zH@#@4^5#cHBUuMEDo5dE>T%4S z`8l&u(-jcZK}ZhNmZUz~7;^IQKbAgZ=$<}GuzWtV2vu8Kwr*tV$ z{KGeIUEPEWY0?WSkn1Ta+w!@nak=d}_a8972Q|pJXIWM0$M5xfuzl{&O#7=R`H0tvLtWtS@3400xw%`&ls(MR)vAr#Wb{SS03-Lq zd}H}z=8$NfjwH$=c{_2BcLK_SX9h#;(((N!+q!%hr>E*Uiy!Lgb^c;U07>*OA5S3kz$``KD(D zNL_itF@^|z`~JNdRfMi#+Vq<+r|Sa)1D~#YOiO6u>eHiTYy5Xtm-Z!ZMjn@vRa@U0 zdpMa!VE3+FmuV|cIX$p8n}n%)(Ty!_*KvMGalRHTF88TwY|r6Chep!zq;B^1=)o)WFNml(B|M&2?dzeY4 zAy9{VUg=3RZi-9WQq`?T<*d+@emh#ij~1Ty&+#cC4`Lt2LkO*>ynINERYLEi^3_}& zlLy)_T0PTq$Q`aWqW%=jZo_H94iXNDfyZUsxCTf4t}MAcQYryzyovWLoU^WiP%5dE zlDx;~lz53xI64qR?Lbq7^nOd#AKA0ttONVugN%Q4dQh{&T-wI*NlIV>NYm&=1+OMd z30>P_Ym@5WYB+2!&=j}6VOH)pP1xg(1~xwS@_>7M&=^1SK6~I1*s(I5vq4dfNW~{i zijHkzNQmpwxb2s8vFcu-_`1v^bMKg3ffzdjrBnT}MlY1F!5(@-C?z(N&K*0RuM&4l z(NjkXBK8`ea@LehOuUZxVF=WuE9{2InVBPdG)I6tlHfUPCAL(*}Fo<*Yd|^kADuyGMYDWjJwm(=V5#7_cXh z4Q$sKFDQ-Q6!GH@bzgwJP{q5_2FmjUv35M@Qk!bazeJP*0N-ad+}bCr9mS_Wd(sG7 zu8%t1=$~^w)wv_UzAtl#TM#bVW9pF^DBj%%Q16QF=O?CNH(^OcbD&v}@JV@)Lt8J} zT&cs{(@)EEI%)dXEHtVNs9y~BqZ|o5l#qE_uCt=S_;OsoHw7fqG!e$-Viqsuo0InabchYLBN@LH)jQOHO8f4PUx(9hT zrxz0z&Y;g_uN*Q2Xan*%-vkUvYpqtY*NiYd~NO9KjbB%F$RDuIuN@+Axr2qj8mIncbQ;UdeM2sq8XsLH(Qb=3j z)DI#KBvV`|*cHlVv5}I*No`1dj_%x;&DN+fLS7CyiAqO|8YQq^i?GEo+XhQ=Cq5|S zTn!et4HCj9R!*A;|KLX|BSTy+aea4XG| z0nG=VD$LyojbIC4&b8o+Pu~Uq2YDE2m_e6I!jO^F60^0kf8kf82UHL|O)bj%X{HCG z5!xMDkDOLlvjj=9>Jg@JeRG>tb6X#yd#$XHcT`{!uF)BwyxLrHNK(@n)x|t-0julV zOshlf_{V@d!A@(y95mDDsrGr`;@ae3~f&3g!p}7e-cCi%W5jB_5Y0XN`nm z2v8=Q9_afwR|lZ0gzv-_=0wrcW#=68_sx0W?*OD+Kw6O!`2%2q%i5>;1v~Xeqz@?M ziY-n#mT>E^%f(O5=O#1yRs`!A&L|PTdaxk3l6&(<{RrgI3{PAJ?4$6I>0UVZMf6hn zC>Vk5hWvCVn{egM2@Ip-M?be3yNBBL8$WW^d@hTs(DjNw#e$j-zcw6|0o3sl*3q2V z!LW&>B?!Y#efqT4nq#2|yJ~PI%d!G-iilIhQ4Ucbn8W@P*&0pFDk}r9p~qhji*s5B zuNAS(SyK}#iVjL25eBISy%}gAo(-kbJ2^SA54PvuQ~ueD7qaf~h%WI=7!enFX9fX#XJ z%q~bUxkfcGrh)5EB4xOI-FVterv1==H?I4!Q5nzDVwDbOI zO!aJsbJl>8-az}Wa8Xz%Sk3&nri1#f8o+A1p=oZSolxQ^6IM>j=Iy%Xs7UzS5`hvW zEFg?p7g^?c*q~qEZ&r-4{7(z;Da~Wq4#icGHin>%cC{nF6nR!tB2+Nej9~M6JS^(& z39=N+_MgHcBQ+!+PKib+9k1qa;i1t|gM!&)GJ>J&3E-##?Ph;2j^KkrACXFDprI=5 zxKc|3!;v64ZI00dW-OItMb6B8QfRC796U@P3oj?q*dVbt&1S7<131M;j2?Y2eQOhU zVAxr%e8+)N<15Ymnp#8@y`r1bhmQH3PR5t&;g2ONC<4_NGdoyu7<2}bm_6Py|vh5f+I&-FpS5tUTuAJTH@1QUBeVwrfAX7N@QHXshzD#8Fu_kTH|Hy>C|s_JTt`lz4KR^8MflfW*2G_lQ8C_OmX0eXgp?-imc& zfHajt0XlM_ya2$!jJYbb7sq)ZfMk;*OL%&IDm-8p55HyNax~-oDTBk!Kz!1)X_$s8 zdpmsP|~FbDlUs`YH+P(Yu z-XqQ8M;6^)Z?8wN`TY6w=GSl-)Y0qD8IL-gZSteo&c%h+51nb9&~m^ilNZSi$2`AI zjS^|P^kXo@Ugq18a*0rgu>^nS@9yealg8je)8bqN265;*f2dAjfzitSMq84#lb}xo z4k*vj$t)k1(PN+t76=9(E6|?pq6jB=sEu0}FmAxci>NXy(PBW^fX1d>4k*c%p9Om0 zHh#QJ=`)`_t5GG)qWDaed7YLwM44V^@q z@SJ1CbSY1o z3DrsMn}5MX_f_kd(5C3G8fIp`l#2Ax3o}r!yze0=A9H8Ck%6O}xIhWZx4YlNR_Vd~ z?GaVVk8`L?>3N=;)?)6@na;;2`(|&hW9DxZ^8EQ26(Z!3*XF0Fcu-Hxq8e|X8)ox# zms?@;i?L0MTW9~A){r?iZ1&FB3CoW)GP4OgdbB*X;(3_mgQKri;Ck0xq&Ca#U+ zes@Al>g0C}mz0bne{@sXMXa;Fx*`=kWSTQs!9RG0&E<{Oe{pco2P0|iNJ&l};{$2D zBj^uG$x_blmqG)ZwR%(P%8_j==l=4cHvS__7G@ZS{t0a>{SAu}6))4ONR(8l9FY6opl++LInJ=WDNHx}Gm8EJTxjYUbFGoDwzw_sHAq z`1$$~@nO9u9V_(>QoS@2IuOdxEF3Zoz*>?zxwRyWAcsJ>{(uhV{A^IG|CU;4Y_Eg6 zm&=V@vRb=E?0*+Jm+`R_3MC~e(z~WoP_NGRVR!sSp%oQ^I8MJc&24_Fbqy*Fslf=> zB75t`^r|*E%UiT+Wscs1ib_Bb|A~b7Mfx+ZPKn&9%X2E1ALn%feR1CH)*3(q$xI^e zDm@Jg=M>sLgjOMF8OYmIy1Ft5|68I3^Ygb4-oNieyp()G6f%m&(`%a34<8z;I)8aY z=wslYbt}s@z>(@KzNj3nxe21<(ns!|2*q}93)0*2> zIbCxhP#871b!FqQ`XJ=`Q~Gfu5xgRNNrt>B0X#^A48xu!SQ`kXG(Q zZv-UE;Ds^ltI&1aRWeG+;6vkPi~Ai-zWO93drg_*6~8v;_Xi*A)INRKb1Gz8YH}*= zeZ6dr(x-CZ;%)as)1wSj%qz0MNmT}CRsyIlswNX%`1)YX? zBmYJhasU3EY0YcYsS`7Jx{Xn356(J-7WP~uoU^y%;}yTz!qW1?u@NSPA#+T#w$iNw z99iuj*P#MewZ@-tvo*=6TlT#kIk9yp0E^Y&SHV~<8f&5ur1a8K2eMfm$y)@-}((0;0M~jb|^Oxmy-4y#e*(5ND_*NtoLyd{H-0BAE}V%mR{r$$mh`! zhX7G{4F{rp?+A?)1<3z5-o94o0OrX+{1sNu1Ff9pLqG^vqc0+=8A(2T-R-P@6>zU! z$;z%V8S(}=I;J;T=^s2y0~vXPASd|)qUHQURm5MGp^n-gk zdT7dNd*#!BJmMk^00$RAEe$>o9ok1Wg!}h*+h6}-qGtpn-=Ni`N6U~evzO;*v<}_G z+crbx$~vdB6ztZEq(X}4auqB3MW@b-PWAZOmaUdO_@mN`cu45^K&gu3Kj(wKx4&>C zr39C%FRqO}-K9}qx$@u0AeIzg`c72#>9iqu4XYoxGpylX*aBDw2y>WsnX>Qv$2gli zODoo=ji+=Z7s(3NQ&cD!_!_jL3X=!K_Tu(RfdU_=evNJiUQF&7lxSZIZ6vRyldY{^ z#v=cZf6xNRfzHUdBHc*YpsJhKlij)@_Y8QM!PMTG z%aW(NwnODTAaFiC+?y0E&tx#R1$3jly6Cz&85J7}Mc+4HfU$WnFI^f0I`mYEdp$jM zEo2(7N*^PF|2Y9`frfTuN&UtVBrSiz`{pcsygX6k$82p2=<)GHn^Zp9B*Sv(LjuM+p=Cf2gG3;;;zL%e z1@lyC5&CpEwrcCmjs{ib4XSW@u zXSje16k%FLsEqigvd$8zuxH2mGo2|fF`2$Y<9`by z!Xz1(pL3Ibof%_wXjTXbT?(ZO3j99o8Sm_8c2pBoU0b>w4qlfw^#mL0NyRfs#auGF zL2R5`AHpYVl5A3?N;EzXfMS~&BeN|P$W^SE1pX+*)pjD_*Qit$-=1PkZBBM&Eh#Dl zU2o{_-8j4RadAnBCkZZ6d(wQU^U4&cOsP(ar4 z7#L0d3D%0q!cLrDE+a?I2Lyg!tSn6_+rl_8&25HP*3UN5f{+r^#06E5kt{MAx*CH!wu%mnNFffpDotn>HKHu`PVBJ+t9UP*us4 zLhY;>SGYy2+x+dvju|SSfrXvdp~=Zbcm$N9|Co`-QL~}! zQQi#asoR7J3&`Z;BG97a9JFzpTfxS^D+?E!i_pWncl)t{F6O%B2pKJtv~)?u>Kh6g z@Bv9tLg^J+%wTh+3bsbg{pK492BRl|P||1k`|rPOJ9J{h}oRlc*E&=OIq519F$O|G&c?-NN-NBieA45N7}c#n{)?OsF2^F zAax#W@#@x_hu_1TzGqdSfgAfWWaDH~*X6|kWQyj^U%+CAoD-PuUC*iWTWquCUZJ%z z#v_aPQ(G6zneR9sML46;c7%uDoZj8W>i`Vo6Lk*ovql{@gcwJa{_(CcW z*gHSaW7%(Vr=vJVR9@p?ls=e44QGIc|0$IA$&-<6^bggK9l`B_qo=&_Nt5WN+Jn@a z=bElvvj&2ww{nUANkLD*1a@3JW!OG4(6}v;{K`_6%AOR6jMj7du(CLlje(B&)resE z#3eyim1x3)1LY~igTaD!&~%-LFXal$Fcsp2!rq<^)WbGNzty@vSsM<_7$j7 z771lTJ`O{o>=Mko{46>at{9n(YV&Dl!O)_)j8Oe1{aLNib)>!& z?84exv~0=9*Rn#(S-KBUU6f6jf% zzn0;KQvkLg9}fbTL*X-{=GX4GzjPm>KLSuO3LumqY zG9Y*92Q=&%wU&m)K0H{k3-z@82(sF;n&?T9oZ+vn)ec^Iq?t7DY8T1)&#U z#=?x&XPf|D$L2c;c2Ny9E;R_pM(lP8=C9{J9~Rg1%;DU-%2`@Rr|8Z ztZxqVtZ{Q5R*!&oj3$Tb>*Y$k>9upsZN38tx6-0kNE3!iO~7D*95(IdaxWnv4RB6n z11K(83?eO~Tua-W9LOh90>1c8+FN|p=TFc206}0|^X6>rI_0PPWPPj40alVD8ziYR z&CZ_K(33^WkMq9;TPwj8sXz1T%>8#HH98C861*5UWHI!&!l6lC5b>87Wbfrmk)V|X zn@P*1o2V%Vl7tdmuX67a8%ba)%KfE~MDK=Yj2l0``-~8y5f8W(Q~wuT=N;Gc{{H{B zoslgSISO&iNLDg3a_lYAPzeoL6_J^lisKxT5z0uCk|HgovNIBjhA2uZ3DNl7ubj{C zuix);`+je?Gn{(AU$5u$8jtJocw8(O0A#J30Wlecd-u|-M|&xL5GKepPw;1|;s<~( zlRC;hCGF8>l4YA;GQFw7m)lC+oB3qYP?!iw$hn1UDD(*y(#weMp?^jaiOm{DlK6Is zdjJ{2T7P;gb`hlAH%W^#HPvt0BD`{}LYS4uW(%-2~_Tynd>? zk`G}>C>AtQcq{uGoy@9#LgAeEB~p-Nc{+Uoat^0u|l{j1p8x-N0zi)*lG9%CJ36c>cTtQ?zXq*qI02`GGG) zkUg;nnDEuY@xIhrY$F(?Gh-;j@4T7vC$4YiJ zAWpDkizI1wCt_DYQw9h-SB9( z?_SYL3gPe3yhhxmTL`WyQ6rR`+*}OmqL-t>UZ&#g1;PmzquZk(6W1x01Pr0 z-~Ww^h=qEBp$Me;u|sVNyu)`!zC#p)(})Jzo3$ z4P>XaT+H#*(^#O~0}{JaON<#VG9;oXrtniEXLQtI!=5zYSFV(fjtmY8+Cc%yRG@YH z_G!U48ve_Cln?U+_}jeaa=-hGjAV|2MP65K3V&y#|M%ll2lWh3xy^mZTYl-Kb%k&x zR2;66c-D$YkL4v-FbLxyO5X|cC~BY%wtF7)C2zqmL1w-`Ie8+nIgbEkpQ078Kp!Md z#*J7f_D=h{6)}#L#3cAwi%d)adz9+oBkV1+e588YLqbC09~RxwX+hufu=soZvA-5) zZ7eaMB9)ZE6nq?`RxWL0&r5CUgFEJ|xgq|xnX?*BhPy)~_rhI7GAl3yF-Z<6#Vg@# zCzMf9z)LE}Y~Y@=wPDsm&puI; zzht4`k~;~2g4@ncg0raCKZZJITU#q{sJx>-b{?`+I+$A=RGP=Z1yAg#5w}iZEe;-? zXcikod5g%qvhV(Tc)2ann2BL1xe*CqD@u3KRf0Ctx8yj+AuFc9X3s-JqN}01Da1uc zNNkk$WQR{w(TqtQ%gf4c{oP|qDLdq72EsJXQvJ_l6XGZw9e!7f;WWR>K6ixy? zU%$TI``WZ5-=W>6CaEh#?#Lw$U6$H~WA9l!tiE@b9c@<$mJW{a13*&`#7mGQq1e&2 z!>Q|1uU4PukbpWrYsj#Yk%Pw){brQdI#Tq^bg-tK@KMBZX+gfG;!+3}P}fy1G~CBT<#6 zm7`^_=tAXrKIznBLp-+}Kh86yW%!Z3rOfAr*`*JUMimr&ZJr%aTYJvW=+}mEw6~;O zX#DHW7n^-wyCi6a9cNn9Ao8oJA){gpPN%fq_Ad%1EP8aMuF0I`+MXmLIR;|fAn=g= zv?IDSa`{yKQ*CVW?TW?Pz#v;u>Jmy%`qV-zS=^It`s38t@athkC5b3Pc;RN&5XGOsQl z>j{R$Bsm|d$(nDZS8F<`qW~&L@=s!fwHAiUx!Bl~d%eAvQA+s$`9=P$ zx|u)*=rH~BhyQT_?!YA)NE>)*Y1e?r6%GzdVUzf9&Ci;A%bt@GgF`e@WJ+C5*;M9g zyNffuH-L=~FwK7M_GruJU-POBF|*!MTuV%dd$R0HSouT>)x3A_ZiBwMjBt#8RFGif z7r{gudkrht*BRZ4o9gyXSAzeSJ`nJ6Dp)0NS#Hl&ST@PDpY`Gy$?FIy{p83EUnc&d z99*iTR+hyo0Lh9p)lV8Q&3#s)9wHi;DVr)&c0l*?6?joX6}wbo)uWMu#UegpYZRZOMH*j)kk)mPXKnAv>zw?`{eEqp7gtLE8}g~Pm8#BG{=|l)8MSLdMmWOO*pI@(HONvq(=CG& ztxFocWYfCwr~P)_YCm#lWyl3%#kkYvm+hoOqvkn|tshxeOd_OQ>}wXSii@J-wNwZQ zPU^7_Rd|c^;cx$ADahnGXNz~F1CGQ0#$_@wbN)ec>4ZhiiF7`X0-aCEKV_yFYghvx z6l8baZIQ9D=zoP5LqRgaZ43MJG-A_5Rs}1eZ1;<}yRqX84HXI+UyTS{7!!f^Mkt?; z!vhSAP`}t5lod#uxIU3KmwxeO?k{fC=YMujgWw>I3PSbfJO?IBPy5tubpuI#-tSjQ zVBWkLCyk;OZJf`J6-gWgGG`$8;#PfWDPy5z`uq`>FxcEdCkD=g`$APl%7@FJ*Va4> z`neNt*gC+ob_*~Ell=9;pNh?#vZM?{VU%s_H6Y?wI6q5Rh*=#MNqcdkphWtC5WX&zt{PWLO6INtDq(%*8o>c`a zM*17TJ(zlxAx(Nsn2^-c+=G^R>eNfm#)lD9OR5&dx~vGozz2xtHaS}gcW!gbY{%ux z*RME6p3sP0S!-Iowl?G@@=Y81CK-rwAWvk>o;B-ZDLNV5+JCnV$p3MkXzmpCqs{FX zu^xN&h=(gF+}=ntU;!JGK74We_O9$=&(vR8$cOJREHPy|B!_Bvy970_vVnP013}~suRCnD1 zQdKA(=ttXscKY6rhLrz-BE@_?m72S1#3uPC#BDN zHBB-+(gxU$p2$qWWyQufPy8IV48J$}S1pm{#J(@J@8ceI665_m`|aYXd4G#{Oq&jN z4QJ9c4eQ)e9*y%q{cpWrlUr2eA)p!?eMYyHp_Hf>m+Ttd-_ zL8IJ$hTqS0okhXR54stnVK`|S(H6?=SfFq_HIS$g1}8V5Smz93K6hryA9IQ?*IWYI z73ghqZ8l?HR7IPD++qr&XTh0)?i2aw&N-BI)4eYod;}1HQoLdTUHDj-HO0M3-0!~^ z&rE@jq}Bs=5kn|S02YT&KC=JJ1~uL{DJ+Ll!3dsWWO&&*A`|k&3Wo7M0r-HiV5ir`($N8T_sN`P9>Z@2~I~)x~-Y z0_FBubLLo4O8YQS+fse0;rlCU?c3j`PhRJ$tI&M+2F!COWzpw|>bS!7OC23+pGLYy z7nc>9KI%r@{{VuL8a*=8mtCRYI{-Cm=qYNx;b*eq$d(~A5K@Lh<;r^hOWQsABwhE! zsZ;l3sl3?xS|w_jQty5Z8n>`u{7_d+5r*q3M10S*>C)n=iQpqN5;>z8b8dAqy_uq#-jn!$hMD_6G zbMMa1zhu0PPXe&i10w15QI zbKOo~#x;V}@F${hIggPwcVPl9J~1!7VA9vpOSZ;(guMX*QWLuEjoLOt?Yj#& zi(aGIAAk5Qm|j17!Ovp2wc_XN{*xfC~+N5)Gah7zx`JWOX;97{L^E z8G^`0PEZEE1+;=4#gk&5652&^BtHk(d>LTOJK2FMg9I?lQf`ju27o-R^i|rd;`@qp zPv~0$VgVoV9TDZUZOxHjmFk>5i%`5)+Yr40 z_(W(ZWM8lb=xR^L@@!jbjBwW+w=0L4)sIhCQ>l8#K>Bj^p@LvW%S`is&|tTU5i&Ud zbGSlF+&itc)+rKq8&%akfSa5$4Ivowu3vghXxKhcN9dF?#1>OqclVj6^ZPMqQqU{Q z0$T`z*82DQU|AW@QbW09K-LTbdWEO{lgdDXx%O>JHIdfw*@RQYWFJc6$2=~YkTgYX zCJbO~PWCZ!1_o_F4Q`*(Eno(fSOWKB)`A61Xk~mOPd67^9b+uMAmVxQS%q5mWdI%Z zm9+)at!ORdo%^1ikfdHu44wKP@jzB} zMdSTh(IGLb5snE@9l)gH&*nz7mt4QbVvxxhY16rL3rbeH&s>HQV0|!{+$J&C0avLH zcSA-(ur3p6a@_OVj5BoA=O0SF0nrL|s3EQgV1uO)V=ks(`=q&_RA+pfJMrKGNO&l40WFl3MqsM9`sve7s;UDG9S9r z2}gU8;g$gl${bdfhRVV+iX2Q+cNDJ=*bOVC3KgVijmc61DPqD5GsFsIjD1Q`hvnOs z9Om+fvoTm*{R-`~&=G|iY+#@vvKHRPE3dDQD6x4oEWPyR^9kt+Y82<}KbvC@_@xk^ z8UWyl?iVy1?T=_@@!<2-b&oy-EnK#b@$Y3*3*$eI79M*f|K#IaSpcMm7aVEy(Z;Ae*ka0=shuvTi;|`TVD90l(!MU?y42Mbh zi=ZTo`IgirE7v~2IkW|1F$0INATwK?7CX4h{}b_CyH@?eBaa*{LM?iGNxAqL5gC-I z3PdjZ*I$9VxAfMUdVO(!kxqh~(TQkM574p8Y@OLGPj%a!JClfl5}wEubOPI$p`(%8 z!zhuZHh+&8;jVOwdROipy!IbtXMuHHP15?vesu=@BFNzvplcuEdZ>kFOlxu`7h)Al znifZ`Yf3T|=@Y+gAcwv%RVkFpolla>GX;!jOy@0YZ{;a*Yd9j;E*K|jb@6V3ifD7s z8LgqC*JETP_N=SLuc3GEFpZC%a+I;JhzH7R-J!!yex&F{AU%QHi>+u_*q2TvN0z7p z?~DDrQq!ilNQ;^P)?*J*N+d6PQ2;C-WoB@ zlr=(hW1-8jCo8y>?(y zNIx#ANzM)Qf{1S4T<2a|G7DxP-`K2 zxLb03I30NEN^c~rSl+cf=J@!W;BS5qzj%23IoaY2*KP+l66@m1q!bX&r*XQ5#`CG5 z2uHKL3qKYaLbMI$(cQG=vqFqZL*K;fp8QOn0?WcU^@cW-@|D!cr=s!*9J zFPQn`09Kz)$M^h3yM}0p9+S>9_jPIA zL>ZlEf4 zGr~~@CS}c6a5m>BJaeILnd>a zOlct~+z0`_@eeiTK*uDYLtH8w@Cp7H5pX-%vD9NIhzGi&WX1;{>zl}nqbtIXuep>R z|M9wb(SiXHbcH;|3{sZKb?S61vdi%D%Zz4s;n#&iT147JLz%&I5Pu|1S#o0SzSc|9 zQD|{}#5owgm5dzGnCHNbfOnvjbmw`U%?=|zxcsuQOvHtlZ+H{i!$w*9wAT8e-l>!D zVMu3kkcoJJFXB%w6gKEPA`bv$`r7P6e;AwYK(_#jO=WkMhsQV|d&*TI(2^H~=*3{R zzU~oQb0acB6@zIR!jhKl+O>s?YsE4NiK>ufL_j-#P4r|s38^(@nLA%khEISha64LZ z4o@G8%!53lF>xuBM=|YfkvN7*hU+BcemYzoII*f~YDJ4L}+51X6tBBMM&tln>0mG<)^qGuJpb)OOFi_Lr z6P1XV%Ch~YJ00HT2WYSG-`)B1Tx^r;&+ z)c8QOR5Dv;EP0ShjXFneBdtBe;sy!|6IsGoWq6bZfC_#Wt$)*sE2-ax&brodC2ceK zrK~y^b}LtK@IoFnRzMn1FRBa)WP-+GimiiUOWamvuA;APPR`k~2P^#Ul*_cwO@V_q z<6L?-@WqK^O*OY;u5@Jdy&G(urID|) z+Y78C=px68tRuutZYlMoe&2+3hfam~TPina{0G>-QzSX?*9@{Yb4Fkj?4!BULUO~+ zHaM9(0q9O_no;1(siWJn1Q;TPWtqgp{Pl8Ri^S22$N{x|hmCam*G?GK~L; zLJHy|=%f&__wBnkrQ?#>$l)jmr%$1%#!~K9?ka9wL%>yl2(Z25wJr#OSr?-WLAd6r zS*dMp)PRxOCC$)9Z7$R1y+i$#Qh}o^d;Bm~FnbfKIsO0_wbY|409aLSEdV~#2R4$a zk*;L*o!H#-;zKqadVTZls$t}^L<%|XW8J7l&L+n=8(Y&qez^1?VC{@{;Q6At9Jx8tkx4Jn8DvI2V& zmW5%@eeZ?9l#szk{ISIdU5WU6$=IetNK{euSl7k`Y^lNU>QN&q8*CnWks4Zf4!~z) z+S_IrJ(0N+t(n-H!dz5_-ZOt~(-B-%s)FCl_JBE|XWUHTKQPoVi}L<<#*;P`G+cyy zd{g>!QJGSyOUQ#}#vENyRdW0L+g`Gw4<6Av;}>;On{zFTU|LmrcSM>Zn_T3r!t*Cq zFu9^jc$j?|nEfU>}Xp%4u!Qk0|t^H)G8=D*;g0uY^BQaM1pxum^d zFDp^8N-K<=(6#;MC(KXlHr|Km!6G+hz;7%&#E71Kz5FI+g)~e2SSlT*dGnsP^x$)E z`SNp1m#ct@^{TQ5M#Au*bJ93W2BFw*pdj9#3JGZi&R1i}4j>ZNl~VDNK9&n>y;rXs z?~5x3*vq+Py@42l14)#Z*#V1AidN={1{s@gQs2;G3#?|lrP(=Ljw!e1h zz=02Q_q1=ziVeTiD-V){p&pDECt@K7>9{|f^hQVKD4SQuU|hHP*_#&6HH4*nNhQP9>J7@ z2(Kcqqie<=K_rXa44O1dAfKvxrxeW%&tEl+8dO%1#hns21j0R!th9OG_}UJ)GGmO7 zZwOsqp4#aIPpQffu}<5#)@hp?eDU*l^7(Ywo9g6-5I}--Skw%$W z*H?GLjBFcxV^Yl5<(cud6Xzp@vxK83PDXU?BHtc1Y}nWJDmi0UKKUOP!0?WIPVok= zx}is;!Vglq!kW$<24DJ5>-KqEl5ZE-j05f8M0M!g^1M;coz?i$OGkB_MTKC-A3~k$ ziF`^hT+A#>t18zDn?xGd)2Eks=XZ6F9uEG&-*<)P&)`tBB^+Ox0UZVsXiJ{v&HkB(3dfa_)M`CvCI825ZvXM zBl4}O`Q<3I@fL~kbW>tQ2>T*N{rGPIU;ioEw1X96*7RgG2rx_6vy#l$Bb6 ze{k&BvDKIniAM`jUv`oKhTZlHLA0q44@0UQ>6W3H@Y)-Y55Y+ho$biKAu312u3%W_ znlS8Wfd|Y$tPGJAWfm8M+}*;yfZCk(hPBRnK0}I&j){?_O3Wncizfku?q=Nol@3Q* zC&W?=)6V8n=Ko+2#bm1`0Fuc1nhpK^*jT=q{*|!TQ;ZQ(Q$vh0Oc*AK3Xu+otZ>03 zb27+0{mnt-=D4HEO6PzSO{I_iG~hItt7I7&Y#)f(Tts!)PY@G-#MEvyzp50w;t>9yy_A>| ziSs^+9P#5p4?%}yqu=}YQ>(vsV*1zC9B$c2z~-6aZ$r;ZaY9)ts9bDq&99YqDWHPT zRJRcyDTsH2u%pEc$js>Gt~8XxMlU3>1R|C!{e%y{7x+yo0EF@%ppwR|L%PPdVi}1}KgWDkncbz1Tqm^p5-^tlXQ?Gm$HcZz#I5bf%)!5+VVQ_7P&zFmX{O!}3Q zo1|?Kd2KE8QdyNE3&a>qM6JuF^pJv{GE8*wLc|2~Glga1POBz>hB)M))C0MbFGCTW zaOcjR|7mZ(Dsj}da^lf;b$}Q0F+wKgnE5LdR3#wLMPY8{^utij#7ux=P5*Jdf96nR z>ytt57&kWI)p8I-W?>w=N%}PKxkTrYb?3}5O4*?C^N0LQ){Nb(ZgYXLF(lQd5D<#P z45#rRW!Nh`H+cDDNSvbPH%Mk%kIV~sLX23O(Fe-xic}!fQ@Yvv&g_?ymmbx~^U_Bf zP=8ee*TIw*5bM(WIk1`~;pIzJq4b4Cj>bBs1>t6tP=^^rai?AGZf0wrDFGvaV+Trk z3#J>=r|mta9JYY9C;eDvS=}#C`q&oXz6}sdGVg#IAlo72n%VVLny^rjMYY_pq0%MG z9CZ!(uL09##x`mcp{57^=EKeBu@lGZ@qmD8q`0QNcaMp2i_~!ZZHVx(=~vacLz_2i zwjJ(Fr0FmTaa$n0!Do2dW2bMsTJM-&Ej`}a);6v=JH_;XS%>lM_nf-?vzNu(hPTYL zBF0-;hP>3fyQ7D%YTwW#uE#?omhczAEef)gDD=FXoPC%XcY ze2Hj>`#EHVJ}xzD^B>%Th_{NNix~Md({n#C|F2%{Eg7wokz{N~@g-&^W-+e0^!kLJ z_x}qOjuQ;*vQB%C`l$rp13J&~2a%?f^muiNdk(4>&#dVPmSv3}gGLcyGlMv^WU`@B zt~uH!7N|6$zo&SX_E~(9DQ_xe?E`0WQt*XexAkY^{{%%W_E3tSA_s$p3DmBeHf>Um zQO56>zK{4L9V*Or_wc_APq&s;t756AXO}K&c~CDIR>|pM|B1_g$30+XXud|JB#oIf zOQ$#EBK;}DLw;`Ec2@@mG6LxmuoLj{^MrzNXIKw@L0`t$5^EvT2`(YtNNJWhgBNudk+(5&Xfsi$MZ_1+e9S^8I8` zb?K31;whGC3Lo?UvMm6X#mPf;#s~+#t97u;I!Hs71EOaCbp4=f?4l5J7nvt*f+wJC z78f&fr4%f~!1TM&vwl2 zbv``_otbFbsm&K3%XoAUXyJ5V;Gfr~LQVr^mYxgdpIEa52Tv>L_%8T@ad}Iy4T(Dp z1jMz^I;vO}cQ6(On4uQ8e;mcBm0cX<4zc~Be!DZc(+V>pI91&QAU)!p*bO5+!U*>B zJO;%y@_|dW4({m_CLiefb)ORN*?sshviXe@MVl&(3l#<26X`&)%CEk}l4I%{AfvUY zZ9k5MAxv)Dw59#ieUrMk71K09j47&6A&T4(w)VgK_Q=WYGnaCj8UysJ8z6+Zgx|e8 z7GRKW;=h$>pGV#RXIz+kbq>FmN5FOp=shgNRDhvF-(FJ?3Z^Y!1ww8_q3WBejTQ~< zogUqQke|ei_Q0`YCd*Q{Cj*g6P{H+mD0t(ITSb(Kd0bP($h)pyz4~BHn^*s}GEDY< z@5@e8H`iv|`8t(Ls~17Z++$umo5!#95Bgj&+q8NC&kGT|xT~~QlJaTZJJIQF-)`tx zJuhUzu@@zyqI+YA_{;I&BzJ0ib(enBa5!EkcQ{P3d^UExT^~b{zE_y9;2pm{Vpiez z+n29FiKDXQg>k7>PwGJvOZ^5<23QQdF7};U4z{4G*bx<%yN=o3`f@bPey`0h< z*K>oN*Qf}VDDbX8WT4@E;Twi?ZEbr~Cvg~?E0({wtg+zw$JaM>p%^~F>KRx4e_h{& z&z^hf;J{>6TqA^|DYU6UnJY>4{3%%j1iCtO`5Qr^;4F$0C@z88SEr6{-A-PjKA zNsA`*#@qelwd$2R4(LErA80tH!cQdKAU$+b{*Ar0m3!g<#`ZZ`u>j^K%O9~<5#XE3Oxa$+}N3XI<1m?f zi%|=TGf(cj7E=>?sYX^UNb0g&jvDWJLfxiE2Zw62lcV9^wndKxf}GdPm;v^Bmg&+S zKfY|LFOI*+&2!8srQRibckkD+gPrv!-opo0%Yq(a=Cw594fWAltLK9Q7CZ!{!YY4& zIL=Z2{hmP%7AWEffyDf0OQ+deOr z^y7H|4ZFZMzdbCeZOJFVi#Y63kQwmvSgVd+$*ACIg+x@c9R$18FZv@f6M&zKCgUD- z%8Yx&J^?_aKdpNtc zggr#y!abD~cfrdsx_7 zM?9S1p^{7Yx*jnt`t_oiEZA1NxE5WphQv8>(EVpBTw9?B3GWQbRBfQD%9A%-l_O3oPQnf2sBhvSIk82py@~ZNO>#evzauTwKY#65J z5bc)`%Yfj2$K6Hl;5`i+H31GecJDwHz;m8x(=&h6s8O=Ii~qRL zAZr4=Q87^#AvWXoL3f{Ifam72TtNh00>X&X1(h+cM<%$47C7AFy#rdCQDVtTK&0kO zJAQ!rb#1#>3EnANtC7x zD!tfRFj;Z;9j>F)dZ6ys zU#3VfAu~vi0W!8A#HoARrVNy1B_D`oIQY!n;fwr9ZZf=;ugZRES&B|N7RZA6{5CX2 zED4&{Aog#SX?;~>w7R$~pE6lO14?er4d&oYVb-~J4{6lSBT3Kz@%4l4V1cowh(u*- z^ZP{(>cD7^{3c#t6sm~~|AlSD2zySe+#$F+%60kyh9zsaL0c?giycQ&;4JVVHkG(j!&^`gaFcJt z*v`s)+hIi~9t7cAs1725<9}jf$#)fRJT&NxGh(g&9>HUY=Yi7C!Ln%*`{QkMBy=Y~ z>$JsC{5g%EV3B-LL4<{J%GUwieB?6ti&uATZQ&{n!&_p!RvYbUz75e&BC9Od2%dJ@ z(sMtJh)lP#-M(vpz4bigz{JgvEw!jEDr{>>7HlmR?hkGMzf%W=ucNw=mqXlHmH$AE zHs6wmD;A)M?z1#8JeLNX^PR}^Y?J2uQ4D78i7gUrVnP`Zfyt(Fl%?HUrYK&sZTB|AwpSxZgO(KJ&yoY%=AHx6cFULU9r_z=SsfHpe9=uR&RiG}F zYIq({k?Ea47%aLHb7^|nCc>5E=^>4{?K1L6$TgU4jLrfDcIxk!>46!nL_e#r+byEi1a5NJaH&9e`D)5Pv`QU#GZUL|G6rY zZ0wwb{bI1@S^cx;&RG%`WqSfg+)Lmh%mKh4--%t~f$xhMbO>fZQ3@ncPxSHSt7f04 zva^8t2hF3sVBZwj;}$MFT4EgBQu%&A*}+W2RMoNAIyJ%td4NEuytoS6IDC$j8g6$@ zRekPD)g*=jVpc=>BV`>NA}Y{l9dFmZ!XiYd93%~-O|f|gUVxRZuHEuueRL8hizlO2uFA&c;GOW`V=V?5nZ6 z0fsZoFUVatDpO~ZpLwh&Gk@7q4%VE*3l^(JEJ)?_%AQZz%H|TTvJ61ZVtUMi)Y&T7Lss51ps^EuD;r=zIIgRf%4FZ{AmS8`hC1EieX-nbZ?M(cH{gI z+wEF!O22LV`EfYaXg6ryq+vr5KeNZO5_GD~H^itc z*6QGV$iV&!Z8RmrRH=j?jr9 zH;yqoS>yZn;Rzrj63%FEE4`jBhZ|r>{1ir~z-x3K`TA`G6N4rkgWUC&-z!Zi5sQxJ zu8UyA4m06d$wFOzK;nxR3$$Mh4@*~hl#;dc@cPBr$cyTkew`X-Twj%Pjlg-Qf^xL~ ze!pH%ysfF?sB~XPMs(OaUO3Wh;#O?j_)ELwW)CP-Df~KF+5zf{z4JdMY&Kp&K_}&o zc=K_6a{wGR8EHA5V)zM4D`N@t`?3#Ls8_|sqK*0eY`c*wMcd68D85ZCv>;yuJ zY_R^hao&u%msXsi`g~VVaNj!G7pAs&AMrR`?K1i5B!IAoEqX8JLO|5EMB<94h-!)d z&Vqu1wL6^W#W9L%s9+-f_o7kIEEKg~L&K3(NIw7=usl1~K&Bofwe$;J3i9)X(C{HG zupRgEH2WIBMrCMm@!iVss*OI=fA~b}fFKl$$qFStIx z)#L?O1<+WnjPpEN_Q4_L7Xg2EO1R*2dFP0c)ZN{>cMrHV-1iyUhbvSmV%-ZXYEz1) z<1Ewgzu?Tm;PU!ov==AM3U@2=U9LcK2j=&uK%!HV_vLui2v}X>;_D3`;GQxTxEEvo zqVi?Y{X;AUM^yvdHI7;WqNTV4p8W=D*a#V@jPT%`@Y+A52X_Lv?NQO|Nl~Vkhesle z7JO_>@{Zq(ebGvJc$bRdahFO~2lm^z_V_po52Q)W9+Wca5Z&d!AB&1~ z_l|!WP)zkPh~apCQPHpT2=b{ct1NyQ>i^d-`@ayC-4!1UCJ>cgT1jlxmPJ+2=hN1Q z(9C=yQWb1INlDjEso^J-Mwi%$xYXMEitOc7eBwpE&4^iFwteBEMS~ErsUTg3M{7*c zPg3v9_qAeI^c>F!aD=|>*`T`$M~u< zR1=e9NAbYrW9c58bi2!_O?OD4J}j1-Giz30s25VUwa(6$Ll?6`60uR>QaYJSP(2y=qU0~OG3R0lr7tRmsUq$j2cr^BK zmil(@?oMl=0#TEK01^D4o13en=KjiflwxK&ily|<%onBm-MUBG1q)3G+M%HyH(L4jblE&w{q)$f7Q7+a_R7VT_ShnJed{ z7QcU=q`2a=+^@s`xBwKCll!G2n;?8l>z}^q=g0Fc#&`}0q8QNuK-O;G?8edxgUgQh zW|}Jx&${N;G~MYn!GhJ?lRf&U>mOd_Y%NvwOiQ6Xi@ug)Vh?;G?1@OvUl>nU!)r#MJ81fNbZ*h4-=+ zQ;(!joIkYNm5zhoG&X@8gMP)?{jl+Q3%$gJ2Mf)u;FMmB8h2P%ch854|~kw zw)mCwx>iUN!;iM&M7|CqFkU4sn_YYZXrihZg1fgf{r(7#?)A5At!Kf}(91eD!l`$I zc%-H;A|u>PokF!4^S^re@(MwB$UCdan9*1(d?t0jSY}3cKDPK$8>NOEwb?Hs71BGf?kE(-1xnJgLt@4>tDrjH)v8!gJ<-kH`Gzc%082C5og9%C_lEP;#{hD zNv)CPyA)YXi>-6LOBO^{7hbzngjw|bqKZTpnyvKe*vkV8jyUS~cf6O?nI_;4VBq?P zkJTUh=uH!&B{~o786A#e?20wTrf;v7IXe8xuC3_^_2D*JIp6Tq!`&(K6_5FtCl95q zL?wkQ2!8g+zr=;HT?hV{3lr9RKIj2)pe4X`Ht zvZ)8}2)ur`eos@daz$F@o50JL%?dWNyKZ*gPa(hi7;JQox!R!QbJdq=ua50N`1jq# zGY#?0v{m?fFhR^i^1A$~vnZKKVKS3)wExbn6L|&U9YVKMIpu2b;->RZY%sV zj(TICtfP{7D6Ix^_Fu`j?lKCGjw4;x+xlW*V`kyDre0d`n_KIy&E`ineX@ecy085+1MK{b(- zx{uSTN^Rt5|BKyKrvN#XyBI{D)rH;-D^tc$vHoe3c_2vTgb>XTLTmt;6TVn}J~-GD zD!F1SfeL=Zje{>zPw1yy>x5uJF{xjJn&9K+C?%*dF!DKIyAfWB`mZ9w40^5Jbt6Lt zLyQdLkz&wCY=Z@!!_QUz`GDlwsI+AN^bp4A7p`8gvA5rkD~ozDUI1qP#mGLuqI>9F z+@eR5L4z%B9Am1z`v`6NuMYd8SeSF_VqZRvY@F~wHRal1;7 zyWjbn%^@N}Wrt_U9WOceoIUp)Pjnp6)jR z!YM_-ROD)OaKY(Ah{(#MZE8<%@R(4@Gw&mf8Lzf<=;43XDZ#M!QHdNUi_E`8D|OZ3+*cZQI6rbh)bC zr;mr4x_Y{53-53PW+3(;2a?NJgnpF=JW%KWeaQ*^Zi}j!n#gx#rh^sk_k*ZV^54Ei z!IfZ4+B{^l!_}=4j8aXZg6UvCS@WrQ$&AXF`Ba}j{}h&k6|gAD8dxAEqB;tI4Yl89AuB~+t**Swlsb{*y1Oql4!(hq-KcxKwr9`6Iy=IltQWCcM zeIi1h>y|9W7DK@LWQ!^^OCK=mn+U%;!FVR;2R#|ZJ9-G8ORZBUT{;ALUhwsO*rWI@ z4okSpZr~RHA!@Q)RX&2bxu3Gypn&9#mgBszy6jt&9XEQ;f(6S^U)WP=R@6j4&vK4t z$9hF_-p|6-K_|NmLb$KoWu%YYXe8Q=3tW#dT0RP<%1=D=YDZQ#_@~Qg<7}8PKX~-W z3p>ElHI~!KI!kXb)nra!0Uog;!fk%5{N`JwS_gR>0(N|kltq2}N=k5K>@Q+3mxpFN z+7gFqFj+MyG}?8|5nkXBfIyp-D<6r66IzC2&@fEc3G!loulDIt#gP?mBJgYwPt*S- zAa71~`Tbp;JI4NWfY7mh_^@H&uZk8e{M+hMn^w7P1Q8}YO<+hjw3q$3fys|)0VUYV zdV?bSBR)QRfRtr$!faJZDN@V9O+J??&UZJn?!EC|d5FJ~;rbt_TPS zC)bG%BAM|T@4JxaD!G)3^$bXYtcbz}?Oxp}AGzp?MLo)q)*2ehxP->$g)ge56pFt+$MKi<8YgfM^=~~r`!s%X$3HmiNwO3*6x!4cRyX+^^(X~lA1w0! z{yal^3k+4nYn__L_3MXiASCI-mktgb&3Gd+mh9Dvq_gtkCmPAtV87yrIKt)ger^Vv zK+39TsRzXR-3%6g1!z&SnTcVXd~0EB-mZQOxy13+F8fQpYcdE@J+SM5X|dE$b6 z(PUf>SraIGsA|gnYDFhjGATF#AWfhZDn{hJA&)wJF1cU%k)JOUHL-mljskX$w|dlk;6XrohhBcemk!~gq3EZ%`wZxI!Rn)ktS57K zI3Wn|8o)7Q$|Gjg_y}$?(his)dnkdCgo?s3x55)l_yw^wKka&_9dJdml+x30({^gC zPZ`&m69C7eYsTiwgMR-v{??cSgPiNO0G<>PSRkoEA$X^+vf{L=)v!%JbO1kA z)E(eWJ8@Vj)i@Z=HrmNF14HDuA-2mq<`_E`YOZ)ja5?I}s`M2uFx*fT9+V7q4YivJ)c#=NBoMnaSpjuB~jvKv57s5mb`p z21h7wDB&^2!o4=g%O~d5MSrR#GgYWetg*K z?Ij3k4Si+ZBhf}CJ90@WpAw*%i^$n!aDqPqahCSAXD+U&i80H9+gR~#rIz~DbK5B7 zYy5b%aBtMFRqVL1w?`-qJtZ zI!6m2Oc9}zGiIg5*#WUZ2Do^KQ=Q;ZIX&6Wz4hiESVze)7~|0Gtbc%>K!mq~t19!x z4$CH86|NKw-fDDDqKIWeD)bm6)~wv>4v~i%3>tvp`t`%ewzoXZbsaJWBY%-~)FaP# ze+UIYmPq~J39jbzNCF}k=~V7rvjYEX3?K>4sM3wZ$350OXgOkL*OE~2`-oHO?=HvnM%I+r-9S}?0d4vDWtf8WY zJ7$}m`_(;QIFP1jn-*^a;Sk?h$uL|2QJku(s+MXTiasxba?+8E`El}00Zn*OXyeI( zHm!c7O<8rZXHSk9&0|fA)Q&bGq zg?PqsK#@Kck-OwZq$Oyjg!W2LDw~QCb|kpWH5>-0C8T%SgIzLsp#+BdSWtHeB5AgT zsP@868?G}HEro)n1Ynu}<6?<{0MMLX1g}e&C}Ix5_u3AxMuwTN9%OxGv!TJpzZnm8 zTi(Emg{>x&bfCY&zbaayNZH287UfG7)=i#^wqT+p{Ab`hTemoBF9=3LFz-FA{0dxz}uNi7@4n)&R|Z6Nt4n-{WeRP+XvpN}&e{Wg!@|jW2aO>1wJC zH2(M_^-T*(U_)xZ?rrzZT{4liwm{>oy0j}D1#50K5+yQF9+&Qa>Qjy(x8w+qM7EuZ z9EKgAB3fdC3dSvlzJd-GIlcL{og)*kDvD_eOOt|bQyt-BH^uHAgM`>e6%6T?NyelW zcl_6TFu6Cft`TC2LK}}G{zuPxd#=;=ynoRk)dJMzI6`lP7Du-D6+d8m@@ld(-r?fF0R7a;z#~5$F8lFB-}Gh z3;)^0pZT{hsQ?Pp>E`yyh;WH}9uA6Ph@)h}IrS2rDO&MS);jeVze0 z5cO<)#&LQWagQg?ccWC51$mT|bvScIKw-VDK^q^63mF9n)Mx02H|K_^;bCm!=Z-O* zSD(7YVZ1S!^^9T-<4T|Uy1J;vzQ#hG6T1tSyr0zB5(4Qa7fgbY>0e*jn`%KJme5c^ z$TOXu7u$V&diFYoqy&t)MZnnEyFp!r{yd_pv zi5x)KEl1y2Nsh-V$71lmt6q<4I!i9KpKVe+>s%UM#57N`y$sC?og{e{#*g{=K z&&#}}D)!nCMsZo*fsBsIp*|1`)#HJmSDA8|%wUvw@x%P;i!}>z4oE>3Q3Nt7+w6r> z0~973A*Fh!uB#)em4IBp9`5(tE+3|e#s2523SPmDX`|20HW+^^D5Nm!J_!s;d9E3h zRVii(H}xp0hnU{^6J@L|6zfBWAZe$*8SKSW0MvtVjToeI+1Hh1nHD}@eD%xU=lpqi zaK#g0R8hUJERDjN=4Gs#K2_?hqMUuwX>i6R*|Xf@zSd{`)rjDvx)JFjg`F7eBHJ(3 z2%6Vs?|2*&Zt-K_`#y@f=+PJijYj}jek0A57UDk_1)->GO|RI}ykY&{P71PljiLDK zu*2!a*8-XK(|iee}HTKnOZ=X*hVmcCcebpz6CRj z%Li;MEe);OwfWL=Zfa+ugLyqg4WNZ3NZw$jftv4PWDOUgFfak1>V_1gh)6skQuCJ{Mpkyx&eajVpT?v9TNPY_~7d=J%g9rO>wz2&!y!ib5Z`UzL zaDIaWgmuL08}>vaQ5x{jfGpMwRS9D4+A8nYac0qY0q2%IJ8+IwY6cX!iA*1#kw{*YenHsL5)GqH>KD;g1gFfT+78<>7GSSRkx2vN)gxR%e2-1w%b_#)Tqx$jwuEfRQq zoXZOah-Wk4L+luse68Ky@j`~^eJ?sA@4XXEKXArd*B&uuX-MmLFtYxh&9h&(WRg;< zS?s30kY+77D9EOgsr&;|v^4{!p^<%e?!MQ)eF@xdmh*{@5c*T;D8(u}Z8-O!B@E}N zH~06k7mHS^0V8r+5YGB*<(UAxD<2#$EPuz}+Rkotu&_Mc z7K$vlwn1shjg?SiskX0|XMn@V{Db#FG0br6;JtHbfnii$&aqy(vL%TJJYdz%Uh4Bt z7t5Qd7Gst#Uko>I-n`@H3K$*F;RfvaA2PG(Z4A1WZ;7X zEdw?cp_&z_n_S@6UOt67tWG#&){_``CpERe^<3KgzW8u#9j|q;_eE+9z=8Cr)Tn)f zLbe>8x3PLkaFkMaG&2JRq;~MU=rKlQMXVQ)Vbxh;NK=Z-%LR{v4E8B$2E+I0ES{s( z(NYgH6dq66`ooLtsNPF`v@6VB77zJH+Y6YD2KdDzSnB^O^RbA>vmr*F`r5B(E4ldbJdaH@_RkWJN z)aTex4TNs0TqBZnu(jb>6i%CyFI=u6pwq&eMcYTv6!9d3v+xU{jg&M?dcucdvietr zFXcu(MPR+Hrgc2*h8)h5?b;bG>ef3w%{=*u=l|sb5TE3o5mJUOkKu;0E>adf8(*;) z>-pWEg(^UsuhE_Y!yTIUTKg}W1Rfd2n!AC&me5f^l48I2Nq|P#oegWSDS8wU8zTkC zquqIDz^=@_40EVG*2LJLf1$0heefVH#C){xfvv5zbmv|Q+)Y|S`Xecv{e!X?H@ z-wh)aZA)nKFF1NazJiRt=(fUAENN*G#n@Nayp)!8AHz_Vtjkg`G1GzOB%cQHSS;(Z zGFpck?*~N+?4nCADi&e1Q;ar~JJ`s&Rz7oVw|0gZI)zgfx1x*!b{Izm+9`Uag+*6N z9=m>NI?1hZQ3T%$n9$yK`pJ=dVOk3wA$+>J3SKmxiZLWRaa-ggEfFRbvp&&)QMvB5 zN$Bc6cyfgz{&|cImALGUq<$gYX#nT&HO?J9s-zixiYw2VZ$g7^JGbmDe<@yyc5Wr~ zrR%?aQlrC5OWQMz1kJfDr8TxhU@UgjwkP%-MZ%wZ49_EY;XCLCEMceuZ8wySaJUNN zl5&)>-T{@uilavv2Js~ua4o3O#&8+IGeAW}InH6IBMXW^&9XGbfU~`o! z2!)fEkuIRR_!Mwb!}euZ5ToUU3Q-H3!vZ8Vda39p)z8owK#G-fAuFv{Jk$QKVo$gV zqAH8W`aBTX4XSU21xo{Iv;#wJ=#Mr`pQ@y(H!IcG_4?X^miV%!C=XyP6|9-Kl9!o&m!U_x}Q3}NG`EG_Kp?!z#g zq}!{1|B36?h0hH+3j2iIqO2GR6hjw2Okdxh^9?}he!%s#JbaWPrEG(aC?X4?X=6(HU`k6Sash!19K>6;fw%>-(MGIO z!CkE&`AhbK)HZ%1Ns?>TbDq!MJ$qy>Pw^*xVxZAcxQ>-xJQ2@{-eY5uaM;u#h`@&( zy1aKROir$BE_3rF290*nqp`D+Q3R(YY`@6>_&nmfd)X{zAIlpXr>-IxyNAyucN2hU z@%s>UrO`w&FcuONNZf(O|DWtQ$>84j1`6(odf~!y748Uqi`9;1dJ35uh|rL3Q!lFz zkCZEeHMLfdPsMyxqs+8L@FO5FQ+{8A2AqvAml=MDLRxkBn(i`#=DO!`S6*IS){3z} z-P_SH`$O>q3{Rdf5aVO&{Libk1&qnam|gF1>!wup2U|+3t6GXq_BuP5Tp+)7F7+wAB$3!es<4Q$ zMHMvpELaf)%Qku_OK}Mz?b~+`@^MU3O~eRRwx@Sv$pXLnVT2xCx z2mGn@f$xFEN$3n`g@$zS`wiao_FPrTTw(5n34|Bo#NYvof^Ad(d~ zL~gb!%(~4#a+|FC@R)Ihdw6dm4`}ji0~_9vxTT^*=YfDLbk=qEcmB?wwXuLj zt;AU;XTTA(_w4pOJ@Is71)-`z$BsvA`lP+a$y0c)++5l5uIZkWZFC$|NN6)$R59wL zos=1a$R5GupK8r(rC9vN4$F3R`YfFM1oubp2#?*~_bA3p*6yz9(E?TyY2}IxULGSn zYbK{joa(cO7hp0$C5Ot2Rxhxxe|jO8;KQ@?tvJYnL%R-wp>r)kf~~B3)g|IH@GT%jmWax*iW?Oj-v|aUR2m&%Lyvf$SPxxKPZNE`J}v*qx^2 z79j+mTFnYGt_`deS(weAxjW)=`(#xi6N?^=D+`gMWZf2d3wDPQNs0jh*XO?)1xaKI zgV?Ma|KCvlc0a)>buUxT>M^GMvT|}0cVot}Zb$kJtbVxBzz?(YVtDG9;pU#`XsfVb zo+TfTQ zoJ71#6$X6!1R9#;^*b9Gg*ZvO2gQM`pMI(W=$_@Wi;MP}{$4xRJ7|v+KfaChxoDAm z&m5B&v9(@<#^Qtt(zBb9>E_yM7vY65>3ol{LwWZ9yIo_siO0r&?m~_&xx?c#8|yvx zc`n_(>L6<+%tp|}&n&4BFE=b_H&wnrGW)*&nKL4cWpYhWxi_LeE6`hjwu!>9j1e1$ zKlenjhkT;@H1e`B@GZ_kc!Tt*yATK)xDaW*2M#=VtiL{=7wY?1&|$RyjO@Br^lGQ9 zAc6GzqvBFvB3Hp;`SO>i3?K5q4*L2w8#**nz2wC3wT&UKpe#7w*D761$VHk?`GMa8 zW+UZZ9)-rWwY$Um*1tbHz@^Q>mE*4{>RWp537s(QQl+}*z*%{E6J!2f{x!LKq29zp zcKcp*+0kQsXrE@idrz}&W4!OHnR}zdu@6dGm7M%z%B*{DXXjVDp6Ga!;dJV&H@XGG z{Wj#QHQQ-;dR+s-t6^svhc9n43NF|F&coY6wmuUyahCP;`winkQE$`5$6JO{G9*o1 z#^cz5ix*<4r4EDm0W(Li-Sq!(b>4A3@9+PA+gVBWh?bPSDvBhbROTT>sN^KcNQhFD zWXq_Kj6{mGjWQZSGD1-lWkp5y?sva@&i9|+_jYc-@Ar33^nSly&v9LkbrpdooxV5u z5XC|xef?yE24VaW2VU(kqfN5frK%Q}QCQgY?P`Jfsd)11y&o|2JYKBJxf^3iFNhjP z%nw6ZWLqQD{q!-QK{NY&-Lssvs~y!mVOlQ^-Z~2A+Gh<_Su(iu`6C?y%yu@0 zRFc7tREPCJVugs|H;FjX$$8fVU31=wWD5{B_vsmxJn)1<{gFE@qZt>Kgvv=arjhqX z$%SW-$HakP88kz3^N91HvT}=nGPF&2F6!*h+nap7_1K7!k5`~{#vnLCT?Nr(WBOS- zb+>A!P;5)liB9_DmMwor<}-!j;X(rfBihflMU{T~Skkpzg>!)m16PZ`%Bbcv}t|42YE?a`aJZ>jmO zZ`7h!W8_F6-XsnJX*-}9Kla6H0VU_ zb~A5B<}=?s=aI8!g`exc^xRDOHMuX=<-Q<+Dcog0ue!)AZNYtR5Sf0%x%&B}|)E9!x#db=p07A)3I9;SV$g$T!M)5=8BCIlqCL!oV zm`FwEs4Bp&(LJc)Y&crlYTjjTxrq!{096G!Y~|foIK8j2(QNyO z&_4mQsP4g##(q25d$ud{xq)l%+`W4RV@dSud)p6X-ggt|1H60`Cp?dNn9p1ov+!r#5u<_laFO*C_)+Ucxb~tj_jM0@z zqpUQdSN${oV{OowzSuH*^yo3;ft#L##G&@?y)}9=PlrH0eiH(!v=1Z3;8S|iNi!rj z06ahvPk6fQUeWW)LM9#2(4xt)2rYa41?YgMp*8~iuK~_*M1ef(;-CGmItFds+CXOb zsY}ZI|Im;Ba;PfYv%I&n5%1;1L`VB&JJeAOG;5YN^WZtOiRb#ZY1i)P*|Y62stKb7 ziX$N;dIl3beHwB9^=M`h#(!hvk5;cQX)TR zj7r-0^VUm;puu(HzrTGs=$-ridj}QwAJ?|N)V8oqlK{5B{57R7ePX7qym9+>qlnuf zEBC7W%*rER(H9;{>nY(VX3QyS`5IFZ#`b1lK|dZp%ssqQ-%W%&b2B$+a2rGCzPV$< zHzvq};_Kg@6R*;;;e8Q6ZhYuw)GHF94--#~P`%T!nK@rl$W~4cPDj#acXYVB(A_nN zhe~HcQ?b>v>o0(T;$LJbb|fDze16G#UhY4(wpNcn(a_J6o!LsELtU^|V@%@#m%{P-5&b6W;F{QIvG$veD>{#xp8TOUu*-CZJs z!bMOg5)Y=-;-8umGj9jQ2fDmb#NqS!+Y%Yf6(-4Efq`S=y;N4{(9&=8T8ogq6RpY$Vfs~fT3^n6yo)v69@&Q0Q&D_Kq6Fh5+EkV*;3(H) zG>{Z5W&l>dHxW<>V=b2az7u_z%qq++fCg7+a7y$|)pB~yJuXKwOUwx*K6(@USdOtr zlBE!t-UG4G!svu(uia z@3%&w696DWEB4qmJFHOhUGQ#6U?%uzU4_g86spYlUE08>SughX94NSpbQn09sLHhc zJ8+`?@EuuUOE9Vy&-Hp-YlxKR#hU)6V9Y!_Rg+vytAHF$0fx`7H1BKP>-ENnh^$f< z-ah502Js6ZGpJtWyg+IC-PPT_bpAWH^p-selCDtljZl&n!6UlJ4@mQisU%62uiaN|{ zOXn_3l0qG)xGetOmoIfRZVlR=5;ft6k#x7)wvC1XrKuD_19gOonPfD)^m{@Z$o~LX z2k<4fZmAf<@go82{Eq~z6YC^Kv!tX8rPWPmS63@r^-4_^a6R6MEK~GU z?}q6nlQKfx#?+GBBn1EiZ5L@j3v zZG^m~TB3+iG1H#vyc9J9DPG&nCrs8&IKqZvPz?pUQK}PvZS5?wEj+ zNPH>9P`8&0yX)v=ppBK}IZmX=1@mc|p~5yvuLyjxYe8`W6vlW>j{zno2hUyh3z=-1 zwZJ=9W$ceLmWPvUSbQ<>AAmt?Bb6xJ`^|6thBK3NXT1V1`c}5N@8wq?B}ReaAn}<^ zTYnluZz*vJX#KS4y(PB|$NK8!kv2@91fbUT4@0fS?&LICZ+W`c!5jAnbZ;4u-&IN# z^ut1{3&IOI^mOrHBs9BKx>r?JI=S^Y*5duitT$yA=4h|TUTZ@?mSB)-D_h4 ze*6xTRei@qWQ2&l(F|%%{DWEkDW}ZnB}?M(kGv!fW{8S5@H5^Ev^lLB;}}PMWeTN8 z6)7u}dQstv)Jp=ZUcbKPKcVR1!wDlcnC;XgK#V`fVs*mg;4p&Nw(fg+p3 zXAl4YqkThb4@E%!MD7F80f6K7n|v7MYaiD{ujaG~gO@&6A{SC(7KuT6mU!FbZJQxI z_Vo?vLhKZtihlJxdv~>VsXJ%v+HRb&bhu|dt2%O&Z^wryLF+W9fgl|?!WrE*Udvf` z(osTb+0jbPn~&nFqt2J+f&Ij=1pMLcKvJkH_9jQC*X100O18&0)HFac#=XvL9An2| zdi9AWKy##@LYGZFY2ZA6ekOXC+8>3N-V@1dne65wX*^_82%|%2JbQ~aiof)#oqKu% zkT#t)`B$#^=~y0{;3OjGfsMXn+z}NET3rgJE6$1i9kP@}$PQP^a|+-zk0MV5z9^}X6Q#YQ4JA!Nh2 zasfF%F(j##+N?T1wzuM_? zG$J%!j`e+^$?0qaer6#AZ44_(n`soFY4dH32|)h_WMBxYWfD3evc3@!U3ob;xdmCh9ob;HO z`;*`)#q7%3-(PEP8Na(snvL@530}jfGDR2OXXaU7kEy7!`alXemh$ptW-lgHB59tFPY%20%_jhPr7cdm3kO z(JhgA+r({RJe8~n@^U07N76((E5F)WH1hBSufFIDB&mWEgHd`)jH1GLe{-LHQ^dLf zpvr9)>3VPCdUixRA~ct*hkXmDjzv2*7mtU)yyDZIT{flXMw|h}wfVJl<~~J{r%^ue z@C2vvoLM4}5jziOL=JEdqP1T>ztycegz~qD2uX+w$wLA9or7lc_kh&qeEXdT4oG|} z@Dw3&-;+PTee(v;DM&0Jk}7ZmoF9O3qcj;%Jd+aLAwoseF9T$+tsh5?CsUb)4ntcc z8crN4{eVKr0Nr2|)4IvAztefyjIwIz1x14>svdEv08i_=e$?G!X-j5qboqfei!YG-|SAi?ZSO_POU=U_jF$IC7BXy8?jc`UXZ(b%6 z+|}(k_R?{V7D5zSaa}05yTlth+xzpB+D&V^wcbEqsfsuO!tv4J9}Mx+QCKWpnqdAN zTZ+>DJRNq=q(tP->**Mmic>%NQ5TM4Cr(^*EEbe{!Ay_Y0rj?%tG&x`&)EWb*H_dr zrJatnkI?k~k-I_ytX>X%xG*I)uR_FEPVfr!4jU8{u6>?o1+|L2c+tKfYNGBb3T91! z7AHbo>Q#4njpqN8VeeGXZOhNo2p%`LvDr%H9gL@7S1qzzZ3^E(1_on44{kknEdlTQ zNQ!bTzw!D1v;YBo>asU)#$rb7=DJH8^~3JhhHSHvv(0~J*RF2$Xd$ivz7J(R@Z!&EWByhCvmcF=JFBCoI@S3sJwz~)zp)QeV9oKtgnoKm&jz%8 z$@1mh6dUR18!IWPgSiazOuM*k*RILOjsDy!2&%3gyJdvh?>jYkc;bWkvZIZ zwJ6dJRm)f$2BvfkL4*{2$KrM3-;ovid@ogsCI@mF{ml-?=B+AEvy9)MVg|)D0^8y> z;D^W(gMj=}F|u?3hG%HTa{vl+ZPn{Vk)B~gmPOsn>exU1O6^-WlO?N@UO0YfQ%v~K zHOShH=#^?de$+zm!HH9R=i6E5_uqewJ5?!zU7-`LtRVBm7TUNopl1N1av8z2ejcAX2GCeWl@%k>);RE6t%$B%eomA6RxJ*+bL&r{{$ZYfOa2R6E_bt?NE=>;+Wf`m@YCO$kh3RR`q1Av5-0&aLkw+3aj6A~S0+ z%gPMKQ@4T!yr<5Uj3j92qMk*EKe@wwh`ojDA?>R5AEOoZLFj^JT!7FK|jn z&XV=%>FKd~9r_U|+KGKP*t0S;)`r8e8&1qCqJQ8Ql+*ojEAL3Q+^w7+;$3#p`2xoy zvksWdses8rXJA^Ov%CY|2`ySRA~@Af+A#r)3S?@=XbMUG4}Mg=&3@{7AN1ccNft7G zl1nSa0$11gIalh6oJFKRFnRsBP@|K_AD*Bao{c+fEqP{=dd5XB&y3PJ!C>9J8PoR?J~7CapwL`7LWD%!LfhV)N9&x6HG(4-7kV9b_cvx8V2o6) z;=M~6A%h&&0hz&da7i~}F6q-fbJwygxXT)W|5AKXr?+g|R_DRT3Z>q+htSb;H#G{( zlo>a&F2RAQ!~`;8E%3T7vt&0Cp5R#=ed<(I{`{i5p63^Izw`N>b=!!TP_P$?N#nSd zF)mS2I&{JtNQ_E3nfvOa6f6({!j}M4#dTKOQQ&S_AoUqbmcJcK$7mm)i?KFGn)Ty^ zdPZL1ig$3Dr``Fvq%>DxuK8z{Il2wBh)FMXeorWlOH z#5C+f*v9EtkHI#GKrKC*b9llJRaj>Uq7xGr%8BbmofW}4+paX+W>L=}D9%CApW(B$XsCgI$psE5tmVTzD9KF}r071Np@5~Gi zJb6*5Q zr+%^c={BpF530qg(nePD-*0nBN+TJq)B&s*P?=MCRn{iA@h zEh{hYl-BGi`#lPBDmPY9Ha(}WGUswf2h|E{h&T3lUZ-P?BW`!^)pm1dV^8aXD36Xk z3Vv;;Qf#$+`Df)7>u~I9&@=_>t|o@Lj!Z_5bhrmksHFJ7!4jP`=2~vAN3=c95%f)R z{b-ZmQ8B5mF99Sojts?X58YQ*S=no1pK4QfiS`Y2b5;rq4^6&uR&H+0gZ}M$&oH0X zt1X#1sxQ#T)K{$f^m?cHknK5Iij5QtF+X|-th;q^{1}ypWw~u+!nu+{wPVK~6BjY; z45qZ$?RfgQb6OEDV~Q%ah0pqa>wM1wkDL+^p_Yp02tQR{5LS`}MKAa~4;XGej4X&c zrc4m*JCWeCkTZ`eryAxT{MP$(Lv9nP0?sWd-@yITOa+XR-`1r|iB?tW3b)PgZa+zv z7yfUHnv**z3xTG?vkME!dP#`PDLT%9LG56UzDnj7Bp3vYsJu-uV$zRNPK4stt}}jY zeV6{#zUQU*fxlN&MbCK5 z;T}zPKM9(CX~1_o+uO&r zxGTq&rGvch>X1H!ureT&DvzIP->p{{-8#Ky{*z>g>UIKy&}Dv9P3+y;s^x9a(PW~wdR-kTs;ME z){=?gx-4R^&rwh_h2`HjWxJ5D`*jp{a6z-roebxIqRP^kSg?0(X@^UvwJdT|ebmA~ z_cunS5%bT&w|Yo7{duF;i?)no)>iG^uz43IPnv}Oyy%8y{ z!qn6>wRpie+O>gWF2*snJSSE;^TpEQQz5~@`8QnLrq52(UiC3ehx{H?A|nyqL8mjE zuTT7VYU&urpjY!!%n^P8TEP7;D17$r7UwDdDd;P24tDe3&ritK^3c0vHOA!L!IZ?F zrPEhboJ=o!XGclL0I(?+IQ|fnZ8k1{c{VPqodacpDQVa4UGS)srSnP>dOq<9Rz|kw+&BJ1SRU1j56gI2O*FzcPIIy>L(C zqSEEr4SBAQ@$Z47`V(LzZZ~vADbrK2eEKJS(b)e}PLW8PG0y9f#?1G=`6q+Q;c!e$ z@p1o-B&R84ehJjU@&(;aq?UL!U1+dhZ!_cuGZCNaU+#vFK=JdZkY06 z=$!U-ePKjBPW*ukxdv6(?S|AwltabV|2&v3law=@6D`5H+5JM)3K5(D$VLI%U9VR! zZHi(iD97h~(8#p316Z?z(h$x_`|(x`;r_9)-eG5nE|dnCx+y{Q0>|^Vq9Fq&pj?xPl*^c z-}^0ka@9T|R_H*k@pOZZ9B~MYaBN(Ww*66?;?=DPIMUz{)$Y+_?Eea*9U-&P0%=Ca z#H@CE!u~lD8F{~l)pt61nAeDZDwlY8XiJwo)~>4N-P&3i4ZRah=m9hnpI*mD+Mo)1 zME;f_69^O_djc7KGrjD}FE(3!->fgU*Z$dsz;_Smc{qAZG``arc!m;KgZfOqBXx~D z(}Byw!^5vb@q~WmTGb}71ahPm4{-nlW?4mrCA{b5hxutfR(3{SCTfS%m!XqdIOXE% zuZxyaTTXoe*43tQvt|pY;Awrg;>WsQyNx#?DeqB4MmMRMMgAJF+b=u4z8kOWB zyX#!Van9v$vpu==R}u1g4U|?|^q`c0n^|8;CriVB+S~p(Nq@T(PImxsw1bO_B_}HY zj{MNy7VXP95~*odMLogcP;s}MYB~s#3;uZ=4VeXO^*lFajmYHTj&tUi3V?+Fu(8Ih zkJ*hY4)pzK)ColU-kWKtJl*f5u+}0}KGX(;qX8R$B01yP;-XLQiW3j_zBF#e#pL!T z5#zy8H*(#}^OwNY2nW-C=kc__+}=RNIvU zydij$_?9E#%PAb{DEw8pg387J$+I{=&k9{N=Pa>CTbbbC8FQ*oBIzY^7Q$w**C$=f z&t9Kawr&#e!3d=3Z@NEis`&8mw{_nWS=D;%e0)j%(5H(^(!P(jog=aBAXJDRzF*z; zsJQ)bpP>leW(2&NtXnUfruQ;BBAL`kWO3;8#MTu9;IMelSO&+?=$yC2B1@MlBjwr2 zV_{^+WL?mB8y7tiHzr~{2#{F2DvySk z`-L|_*FF$}M8Osis0hx>{bs`^0RtA3LVlU8C!Tk%L{arY*RK3ol{!ygt;A)o#z~Ac z88$n;ia8HuWFa6CQqZkXjuHTZMAF-{j&HRl@EL?8=|U}l680nyX+1WMmaVxsmk<)c z@e7&xU|zW1?u+9fb!fcn2 z`S`!XdZ11B?%B+6~W*EWaRu@b%(xlv^%7$n{v zG2HeMJkw@iWtmjMt&)XAar^!I|42elXXP;kFDL4XuS4cRNUO^v>PfD)aBvbVz^5ev zyafVP0QV~x;Hkk?cV4LX*G)y2ge2+EUx-hiW_BbL#ne+X0{9rvK&`l1KqPM`{tqG% ztrE&E;TswD=j1l^c>C8rZU7IE+A^dLCbcz=h7Htlv3YOW)-##E6_F|!8z|%rB+gxE zj=A?mo+Hy~6}7`>=Lvyf`sLf53XO zI^Kp!ZOGlqH3eO+7W?Y5_#8GnYq?fuH3^puiB{$}xlMoo?lrvL@oKEv@X zE0by=i$?zE*4aazX76K!2|T0vkRjib!;3*``vWb@AUX;&#ecfOXIw9&)>wyBS&Sba zh{;2YLR@{G=hR$wk!l3IC*Mc<9LgW9$Hdu8e73>ta9S{DUN9O(a5epNt`x z>@Zd@Aioo-M}ffmob^k-R?i~5G?y>>H||x8ShQ0A%_U7_Y{EJfnJ>==g@bG$thuLW z^}V@Otv3zAvOU=6*Wio4zu2J+oC{a`Fm2Vc)O!Ob=%#nT=*S{o0~&@_L0sSr-YQ+t z(0ca#%bWEDl@-wO&6@>hrp4M83}YmO%rii46IBU=BB>|!>yAiOZTFoZ5it{R&z~O_ ze)6~oAG(|ujob0#fneO?8ncdaV|SmCxoytW537i{ft?>3qRL_mGT<7;s@HHT~lD{@C~}Sgdts=SwGjD zH4eyEqqA5HL%4>cLzWWIYW%`S0{|@o?K|!EVRU*!G23x8i1*{&#h-nUd^7`>oxZ<7 ztJ%tUXP&Si%gi&IZMOpQ4YO4y#X(pCdv<+JIpuh4t^qCX6-3Y=4_z>qK6&9;qK%9R zFRG*(0p)Js&ZSagI&&k~UqIEUquX2GP{;u27F~v#LU+i|wQ5z*Oi4T=ja%t33npar zvxz?%AW{|b0uPf+kU4wd0`K3%3PC+a#60tQYZ&RMR$@p_FdY7tm93yrh(4i7bs&S3 z_wQ_gDaYhOU8R8hDM}h=;pn6)rX6U2G8}ViCSf-uT#eS6q35j(M<>IpxM0zRAZif1 zpg*kL+0s|5I=y$u<7dV7j2|;SaOsZ8lO|41c!{t$c1b+TUTXc>-(6|;7FT777>#;;lB@_3CY4IZK|e#2~Oy=@|UD!85otfW?z)k9?XT zXHDn?r?phlc$n(m6(tqALSNx4nFJU#v3 z)vKccYa1DRR{F}AWCowQy1wl)Wbgl!z$%NyOKWG>R5`F7#CwoZXHs9f#IHB2uo>$8 zqc!0zvKM7XLs3gTfsdYC${rLR^V~G&`F^C1knui@g~NhP4Ht_?(S<$$ zI$D~%g_fj0gbrEu(zjMk`QLc*VVj^F2E9dFvckN znW`e0eynfo5uWG5ODy=Z!liJU3Pr{Bmcfz*EJ3^_Ck)~T#7^|U&*4C(0z1fP)ax>t*M}xm-mvSC`#=i9(6%efUgQr>VuaD<3x6A(s@3QB7ds9@|4UsN2kQ!$f^mul~2>KE1>fRt#( zs8Bgx5l$BShLzoK*)VAuUvE9tzb4X19^~42Pq;VzZokqRG-$V;B)7775NL(ntdZ-yo@LB53703f5u6IHI)`p60AeNmZ_ z-zExDQPdFVD@YG&a3{B-PNF{qiIN|X9Kj{!SA~*pZ@B0{tj${$z)JuC>rZ*qCmhoX zxCinft&|4ic38)yEaJJyvBar-?575uNgRN}m+`Ss%%N_`L}B{|r0mVNyNQB>oPRkjyst$PoaSP z5eW)X+%OCx%|!CtzyDz^huuCS5DfBu#HbP*+e-}P0KMFlR9<6{#3*S{$*zY$q^atM z!*%M~iY9ukH+>>6Cx?%QtiL|&3&J~{wNsBsb^#)T-csO5esm3Q3bfo z(CO!cnUMz3?v&{Z(kBt*r`71$w;nrw(u^5BYVN3!h)K6Bl>rh+M9uPQX)J*2C0)>~ zc{6qBaMf0=TDEJKWA2u7_3D62J8^JYZCpbWcfV0p{dzNE9}$-+@$@8OUP`d1y2TeJ zB{COWT?G<6t^zK@I^5=c)N1i7W`Lz59;nY?iayDAC7S0lAjlR;Y~W@`(s~&YQt7n- z5(zjZo9Qf-aNe8s780%`S;^-)U;vu%zs%3-3`C1dTP(4l)G*o=OZMyS{=%JQj(vxk zp8>9$d2x`=9^VYz_;(uD?(A&RWRwBI+;Z-dZxDZri3<|_b^6zmOw1eo@PGOwcAN;h zA{la0{IdUX6Hw^XL(bQf^irtrL#2JRcM$u-%_sAlVD}Ivj=&`dJjl#L?UsIyuC7)g zR#BgNW=(8GiNmIoh@;SLSGi*+;DT`eGXC z*wKuJjoWI=A+lDQBR$)<%Qs&GcZayb`B@k<3#I-vY&4Ii>`$Q-@HAE)M~TT#6Xs!Q zzFEIrCzqu50r@{AHUuS*%w3~`Fe93dhZ`t12%be!R0Q!)h>zDHz8_Lu zF@6(bV*nZ68&;tWR#Q~47ynJ{=F}^)8E5m z6YfK<7g0SUY>}Wb4pnYzmEnszwr?+Hu`MeZGTfLAPg{pn^irwPBk!FQzYt#PpolH! zNkV(t>Dbu%3Jz?^UTj&;Tm092N{a!9vOAK;$a;M`y!QL;o^SDdG^64oC$RzCrD6_e zAs7I@8T*iJ7>y<8k+ZrjtD$;Qrvz=1F$L%p1qrsGc9Jv5$uZAuYKTl?{dniV-BFH|?Oj~4s8r=p23%)_4lXu2MnL|;csv1ybkRTyf11dc|%TaO*CWn$6=9M##M z@Cv?ZKN?4|S8-m#qbC^bLY=TKr~LmML8xMoNH^rIk6yfQ=&Ggr*AFT?VFv;tTZ;mU zH0OQIZkc(4b@q#hn0EQu$M0^ZP4yAd{Ot^#nv8mLzn~z+>wPuG(AWr+GWo+CDP~eni>i(t+ z@(j60-$Yy-!O`!?0EOEoKbuK2WG2==UiHyr*H1F!w1R^r)$Y=CMmY$_b5hgny{w zcozsS2Rdx~mJaFw;zj`?@*2!M{~29Hi*x^e{r!1SW#f&-FhHOLbrkQBB1ifUt_+Td z3A1N!r)wk_MFMYHI$*KoAKq-Y8%00+?BBe!tdMKx)D4-w5f?W;bA(>&CcYu7)U!0N zacjtwaljsYvjc`mlns4C9a-#QVV@s!U<$lzu^_nik10ss-pS5#nwMEB1%s`@ASVQO`Y!bw)8N#}0& z@G;S2WG%53A1~thl=`*PLIXRqX0Cc$Afky=wB0b@(&d(K8`rFln^-wan7L_N@R>t^ zTBVgABdqH1hr}=RF74yEkZtdvy;<-A9nUJ7-Ii_~WqV!D)c;gv=Z7{}cnAp_8|Q{c zRNg2*kmTJVA*rfOvexFZpHLG;S=>>j;ow#Bmcir()>TIaMMcZG80un|*Pu)M`+I4N zmKF7I9ry9KT|SfbdS#b%sq1H2)-XRU_WK`)XAM@as@ilMhou3|S>8ItC1g8)*XkEb z{6fr{LOFp0WHq1l%XaeQ#3^CZ{z2J1r*mCg@;e&}c2%>Ie*n+tO*L=*bv@*-SQAku z`741vNjhoNc6Xl^DqjQ2OgQL+J1kUj$CzbZdy*p>OA&q8fc-R7fY2AbePjZ&6y+3( z(w@uPwi)n!_=k@l@jzv7G$j9ow46nIE~EeMfDrZ5vZKv(c~$>K;n4^8_qMfrmwV&J zj8Pe4vQ%Av%whNhIzO1sEo*yKk8ISuqjrDq#8Y}Pz1qf1iEKd*Tc@nwXBaEh1RL1Z z5XSg4(x}hJ-qPanojd9p*OFG)^9$sd)0#=RSL%0r?hO{E+KFewCEZ{J|f|-JH za(#ICtP7ucT!ex75$^23xvTI+%HsePMb6o~`~!|Ptxq7Go=XV8ER#S(8BT~HqbWNZ z?CEce`KeQjKtv5YJ)@+@)W@H2HuI5?GvmJJyO@B$|)q(|c5+A9W z6}&aqPfLOG@NjI1QX6EOQFJ=ShMaNt0edc?!PHiZxP zAgpN)?)I0a4pr&dMYr{sX8K(%DqFN1x%*3pGY&SW4(LPb9iH&*hKmK%izItMiG+6HL6;7oQKCC4q7;L5|ngX`h7gtqK@ znm#~&ZNJtNN1b=2CRHT@tvrtdeGU)|)`cDW|daEUoq z7!^En;&+qre&ga6HKIFV`Cq{Wh()u`9j^u_sR20+Pvq6V3Lq4q zuku!gd;|fM=@EJi?Gb?Wh`ZoU~j9}M%N+%Xxl6o9f`(={rCCrE*`{3!T0{_0uCNFII zLtjd%L8-V_=9GgyJSFYF;=#R~pPHDqZzk#XhwT?95Er*lfIypvaJ_MM5NQy+@p3%Y zQ}$=G+rIMnhu2%Ge}aV|31DO#N|t$Q2~@$;%F1RY5iRg&C@vE`A}TFDNy5FHVa)Tw zhO&-7<7`=0f-B)$9{|8!~X@L7L${{5(%ZXz4aMqe!jJ64vb{2->+J;~GSZP?p* z3$cJ=jHPYh@)H<_D*=#$(&+!HZr$BJ*}kn^WqaXvVq2yUxc(kWrRMIKu3`_LetHJV zB$&Ny8a`w1#~658u(?Qk8yDghq61SXu1Yak;x?Fr#UsHW=zkA!lu##xYqcfda9X;T zzC`>{FHPUCua03@Az2dc0D@OueJq~ox8U*FC1e)tB_pLtK>qv=JMJB#0~fQHqhq;k z0jd_^(zNbV0UhENu(}>VJ~O0gP;E|0c;Kk%>9zIN)=Oxfd#0)Gp=&xZzD<>$H#~A~ z&fZOXT=(vaa_+NxdZ#rI?+wszmt>vYrkA0)>AY6+LcB{i%-!?i*PqvhALrI@ z?KEdvb>Z^7Za0?=e&uu3Z`I3#%c>LSW^O3lH2pEBnRrVnPDV@{6Nm^=BQmA~Q%rbt zi*b;k*KY{;>PM>tu5F&^XB;N@KnE>Zu!!>Je&F~WC=HQ9snuYiPcY8Xtq$(IEi$9K z|Bgk+Y;VOrVhpqlWuZR}N%@FViPQ-kICT|bClm4pm#0CYhm7SypS_++4%^5@=jUaT ztc!l2oR=h49C0k(T}e0=N(4#Y5S$KJ2l2eG@Emlc!OEM{*sg4bp(;9y%|?zC=-tHo z2a&YaP7QCd*1%W$R_ti35t&=Dr|TG+!HXW>cbO6#z-9_49lqw93M=2|RM`blFCi_< zYNd}DQXC9_et(?}iaO~CwhkqYCz3%*WEg1(^@P8q;LPyyjeJW?d?s_|WkLw|scdri zS>gEnjVCY;%+jgRN$6>)T#_b;SsV zn=-xN_NH9UJrSNuij_FzI5D+5wvb10?X6JXGX8*HC|Imq(_}>nl*r#@X*4u{OS=_^ zPR7NJnK|=-MV)eP3fwmxDeT!(ZNmH<(bhd1sP4bx)`OlQBbX4?9zakoPrHR$(^3Ee z8W0H5?uC#nPtKX#u!T~TDH8quueGuktz6jzD6rEi@=KIxrf?2f=sP_ zadRJ%C6F31Q7U#EIIxAuHHBlB&croFbp~7G6TTz6Y}a@bi40f_-81(7-&LF=O8n2C zM{!O9nu#w}Fm<~3VCAhz6R{`|-xPr6vPsB=nw3MjvKlcmJCHL)LfKd(1p3Ev z?~G;Jlnv&Ay6_~63{W=dS?GIlBQo6MkYgu$=t|$&EL;>YbxqMG*B4D7Wx7d zqQb4gR%*(-%RjtRnKX{xlWKMNy>zHHo`;rV#wNnx^*K|eiVt415?%t?%TRi%?is(d z^4hPbQN@PsCnL8N;kQC!eyWbY zhhBQ0=^ugIWY9PC#-jMGb6nryd&WW7VM~A3*BtmSjF{8+U!`pCf~~j)8FGr@CjmK`ia?%IvyV@g-z&mN3n_9{o6X;j_w4 z$hrX~#u_=9S@bPqgy%;N1MHCuT``(x{rA&VN1;5G z%N`J}-<-<|NzkK8+3PVaa`O$o8*jTgK?Bz5%f6jhStlaH^ znOCUp-oqoMKD@=Uff)%zeXW>-Q4m@s1OMrxs2Vh>fGmFe{V6@GQ-r(`2A4AoEM`T~ zSveCmo&aL1O0_HnEtQL`XRvB*wYC)v?H~K~Ad!>Keg|fBYQ4o@wn7`jc|UgPTB2&^ zwZUG$bfBSOJL=lFnGM^Zc%qPRd3y8GC<6 z+Xn>&N8l$Ek~7A}RMdKBJRH2jZqlR=`96ZJPMPvK-+*SF{o~`(2^r(g=vVCI9XogW z;SgP{M>VX;L$WWDo9BZO2dk8k(&sV?5iIz!B%!SO=u8ff1@}$>ZLo$(oNccN|h~8`8T!okdb!h_I2Vw~@18OGqFHsp8?UYR- zw!`jWqmh4$3_<>F{U+OUpaL?jcJ+TUW!d%4Y;_U5^Wiwr0i{v+a1jYy&(%UpNb4wI z3#T|gv;Kc^a)3h*8*x39#DLD>fRWpqr!Kj;@NReC)?4M)x7xG~)<{w`oSU}a&P+sA ze>JA0sC%A|ez3YdR4F$$w zE_L`j$!!AFrKTaS=6KPJbnCdW1v2CYA@wNA+s)%Yp=oI(vOzF35^^P30D4hVU%w3( z!>KN=0Gh&c6R(}!=8u&d<~eD&AuF4Bd;cESVb`Fzix<0aWn{FgbET;n3C}=6yO317Wy--zXp)4~_9k8pAADopNtse?Q9f9~u2fkZ?20z)@a* zqY+1s-gNWwD#S7E9c@&l@Ezp%rwv;O_n0p{3jTEsz;ys)q1U*;xxfP4elkM=mGU#2 z{~_qY?4aUgHTf47!YzUGWVpJ~27@dIZOMDFbkyF|#-|NCwVHY11B-6z)F$&Q`G2WD zCVkU5rS77A_Qk7Ln{PhmhW7)(WQWdS=mG#_v-bTILR1lUgvX_K^4qyyQxaa%yykEM z@=WhK?57wIJy7dElYS$Jl-av{!s0myQG(sdf)n{jSLm0v)eRyu!ar2bM@0yd} zBBTx677})rv;Os)hJSvHn%SovPY(Rv-JpZ|xAVNy6y9%AeT$oXC*o`DtoNmVOMa@e zvVU)oRH|N!2+GflcE7G#cIJT~K$USpSZ*NFMj*%R=JAq)vPi|uvNSAA&)R&RvvV25f5z7?0LK|wTe&=? z34*3%Qo@}r2Ns>Q?dB>vLC~1T7goe&8$_)6&{#%#u}c&(T@Vs8kP9f;>i~QF1qMO)%^8lMNw(uvr}206@@XX$80Bye2^X}jD1Dr7bbn=>x(rCkh6<6`FlEf%XvLNP(*kUxxjX!zTyA~*e&FyE11~-L!Tm17 zRj~tSUcVkaGUv@UwzgcEs0KuU0TILF$ar@zKi}WVf#)c>q#T1h{p4?PY!{pU+HO-( zLxFTYTXyE0#H*R_4M0KPG-5TLH%-GUzgdGu;}NDvDIu=H>XLq)LNP3p+*FE?e%+LYd>@@~G;TRdB~bE3XgF8*@ZTq6(gB zGk9e-*MC`4q73FHune@ezY`OzPj!*g$vsUBKPeBRID(|mlc;deP~6Aj-jD^7Fzb73EIa!73B;A@cK$Vs}R*S%9BZTN8F?VBq{|o-9IRv4=?Fe)OMIfB~hLq{r9C!J9$z-@+2Hw z!6v+am_0-wg^_fJ|EcM)`h(DIqjF1G(Clh^Oi=Mml?GJWIPjOw#a|z+(0g~KnoKX- zIvu46Hd0B!Kk!n<2ot2%@2Z>{ur=^iSI`ClII3FSNITiSkH!-?_hbvr?%leL3XQcM zJ65&&&oPJ(p3}3|b17g+w{rlw8Z>Z=idmLiYjPusniOM!gsf#?$-i@S?~xtV(V%+J z_?%`m4d#5cMB@p|oz1XM)D`Ip3R|Kcl<8e1jF>6kGFw74<2^(ATh0K(WFZF1{VcXU z)HM)w&yZZ8h@6A7<r(o}$%+FQu4X z^trZ`#;_@fN+cd^=9_k?wGkvLh5Qm|o!fEcPG_WNh#4VZt&BWaP}6e^0fI4wJ22zHdcDEK*X0+-~GWoVT&1z zW7Df#rDhfIGK;MxV`H6C$bpRxjD~WE+}wT`U4c6jaOX6Ss)|sLRI5 z(x@mckFKr#^Y_bxx`8B3P7hmzHM|Kb#lhY`28rr~GF5Vb0DiN0tS%wZ$_1{$`Z7C* zCU_?rv9dv@G2oN~a-)%{uaM4{LxM3M<}o?snCO7_Fn~mT@7evk$o7WmMc^vYIdcQI z-fPKflfzHuz;W}66w%GCH@c7hL`X>*B+m&!oya(Cy6Hr&p9eLJWKbk73`=5Z?byA$ zJ~WR6Cwlw9yr7mKh z;bno?J97;e=b3(z#?3$@uByur4NWmI1IFG_t?c4^`<2MgWrPW)-iF*BqJHNRIx=sP zT4bTNtH_{R5US4!+xt(v$U3E!$1kH08765_GE+G9@455olVrTjrImNs{CgA(u}tvf zF1WDf*>Sdn9E5;1WbKTkm`9z3z^(6^dan^()~VOf!ss8fYqho$Ca7DV*ucaREH8v# z;6!V0vSu(4L?fIP;6C};?TFo%EKkvZ!2RGf@}|c5`MOF<=OXbfzLUV zkpaw=v|>-st0=QMCY9Nf61OFqZoY}Onn?xIQS`o%tyKetx$gEWa=|)r(?n(^g?{Ex zK{XOc^0fw)c(wtLRx-;jGWeY~j+AUQ5w$`vJUZE*lb|koJ?e?MY@@O!vt(YUIJ<@I zf)iC6FnTpr%rm}BMtvKqFREgJizL;A!BW1oz%-uPYCSX}_t2yT6b~b*s~z|U)sBcp z<@V$uu<=I83|S}6cy#~k zjp$a`?58@Gqdb#&=M>n+3xAiet9DX>Qcv~y81w}uNLpw-J*_zV{mFoo8LNB~;jAd+ z3I?j?XX34x7P>nfu$8JAA5;_YNeLaidv{{KhN_uG$lb@cCbDBA-)iOe9){|eBP<*F zXg}~snfzn_b@e%np^_<9y5?hZG=uSsc4FklIlIECRZYBX5}X+y%p=PoNNV4(Kcoa9 zDN=`n;?Tkoqb_v^M{)9bC0aF0Ts#*m_beql!<{GmMwBS3^GHsAGedWp(N#JLYwTwYRCdc-( zXvJ-^j(19Q`d8&0%n(eHn2HmDx6S`7B-obzT;rBTt@B4wD~h}b zB4Z?aNbyeNZYRcA86f>=WOI$k!eyMNlbuwDUw?%{ZeplNN0Q&M zmN*}O_ock5s`=ISoP1x4yggpI7Vu~X8ylC?^$Kw$STKiPOItU@y z0tff#v12zyj(juKYgB?L=@s@fbk8nHh~h*8L~%oe$?P=XP_=|To?L!dKwHRUpvjw> zpud<4EiW7dt4L}use&-QCB1lF%lMDS(GRMPR}VGI+M4-n4k3?n0fV1Oay5cAF&BbT z?DSYkZ88xEQ=$U7>jKtxg)R(2C(VoYikD*Z&#&*|G{jfZd#0bM(QQhVE9Et382=;H zEU*V}O-d4u$8Ku&G03lFVlhGHR~Y?HOQNkdDfMp8V12YhiaT$@^w|Q6J5f$~JYl0) z`#dgY8B&Q6z{8?;>#@kl%k&wX`r`9s!sm9}CU>V6`>Vu@@*Q<54YM?wQr1z9WnQZN z)3f3Z6hoN|q9IpEwCl9HXOfb#*cLQa-74-_^!-SsDGo_F_Swt@Z;TF_r?J)RC}`kR zw?%pjCI+(uIC%5muucf6f|aA~Uh7|%;XE8hhN}-CpEoqL)t*j<2Ai$)@)!P0`PH>un>KU7OQaSR^nlEH$TI_DyQ53&*jh5-iDfUjnpD63RaxKD zT&yl^Yk#39Kz1fSc?R8%oY*X|3y~u={de>k!3N}r&E}KKR9)#&DN*^fOv;Il%+wkd z%Ap3BuozBxT&X#6iE^aWLp8$sfMs1waoDyv^~=7B?Edzic|XnIz!l*}o~c=0 zek6$X$4An3dxX*QO~}E{06|@C?+9$}j0$36%+Cn6vDMGDvmn;2Ne1w)$!_QH?m|3R zIOAk9IJa_GNX8z$mVEs1!9np50nbCebuRn*A-6^t3@JG;a~?f zTGJFeDIRh|=5lCErvd)S{J~IaCp((d{kNY@DNo)o_*NcyUM>q37@R95V}8lGnFf@T zp7=qpzWO*Fr(9xk@;q3AN+#9W6!p~8>rYz+>N#wxz5Sp3FL7RL_>T{%A*R#$J%Zfr zfVP7sY$3~)W`EOfHf+Yl`Z5Aq{ww!$huplpdDMf>iidog4vw)S4;r3wE1Y=yQ8jmN zAR5vH;%6-bA%JF$V>K5uZ0_FOyK{L?3mI>@C8yjHG_Ky(j{2L@@%x0EETWfZH97Jh z9Sh@T&nHY4gGnNnMMcUGSunbJ%=ZhRkFenI@bZJ1IRUIWKM_|kCZQX7*Y{!QGdxF7Na=i_O`ATk z_RE#yI>zZ|Em_ppsz5P^968OeNCO5cZr-|e`q38z1E&_$p3Irg&C*O^yy`>bwcj{u ztQn;t&zR$GXA0=!qWs(bja&I&-?wdLNm9zJF~jCxSWj~c@{mniq+T%rP&Bvf=i|U=u;z3a*0c+zQa84huFbiAki?CxGyovTGYc}06&%R;iNiN3t+WMkL$_$`(wvTo;sXh+X6 z=|`Mx0FclS&KPV?zHR*U+%uC5$n%xeEWEY<_WEjnrdol3R6-Zul)u{&HHk1((0!#YI8te zC|q2Y&OGyA&7wusJ&P|sJbpI9@RUpU=vNDEkKpO13+Q)MTdj$PzlRH#qOjMv18aEa zVsu94LAy04HQH|U`GbE$@)Hu49^Yn%h5$VsnK;flZD(p3EGp#@`lZ+>ZqoX)*Wg@5 zv$&swmk;7Zf3|FEQfy9lSI%Q01KI4!4|Oy&MmTlXB{Xkp_r90|$!|xH&~xv~20lM3 zx>MCkHS187Iz*6>+4m2U6W4|BB$EL7Yp(p+Z&~nMj!s3bo8C~QVu)7`!>4m38@6{0 z#SDmZvRnSw+)d-h6M@OWaaE!hNJ@ zn)ADMX;0I?)wTQQpZk^NcP9PZiysV9ROCr(OfFrop*&ako<7ZkG^kG0;y86F+{tlT z26RQ?dbGD0LasfSP~zFRfZJkzN5&!3C1~w?B*fRzI7L`xb4B>YkD>fsU<#Ooo>cDt zMirn_RlGD$`_5k1f&%+imwJ3Dv{VG;{y(bT1Fq-&{p0>-Z^<4d#6h+)qL3&mqah8^ z;HV_BOJpP~DKg5AXo#XnSw%^ljwmaXkV?r6q5FB|{QmcSpU3a%ggba`OZ0-E_ZbJb5yOhDLA<^{30S8mb1zsi)esYbOJb_?@lY zuJ)JwKFBSCKN6;NJTuhvu%0TnL-)4N>r*l|fF(xPt@O=xtNlJS{U|E`l#j!mc~U1GkAW?)?t5kuL7Ef8@qh- zH+BG|kUc$TqhP~`0-*BHd7dqeD@sz^XTRq@_bThJnD413B3M*og0Pg7^vU^({oC|M z+=UAnU=vM_IQ`#6r9O0MYh*O(9Nm8w=_nu!Q8Iy430gzU!W{6MyI0<{%Ax#iEqyl4 z_(8p|wEs#!FO-=%aZUlodgNT`|Inlk*OPme_G05W=7x9g*6rw|>VH1#1ezNrgJsZV z%T_m5y?7(axKZQA4vLwqyK_RPcU0^-Z~y`T@IIjbtV`!DeK1)J<-()$92|Eut3&H{ z0h$8`ws*Taa47RGBk&;Mu-0)mSv=oG^`w|ZJ5#m|9X4#9*obJjV?e%tky^Yxt#EUj z(AS6?9^$9qTirFXHAPMqdwS#_b*NaTWR21{w#SfHO`*hyKl_< z=RhVB#)pn~r5kv|AQ=+iYHmL}STE#TMnLC>5zmg;c&)b2Zw>@+;ynBmIOi~z=#wWi zsOmV6I}(jM2fSr2ob6m80pfP7`rnPl#K0lL0E*|qF-5Me=1Mz>Ou~^NKXXy=EFf^O zpSt?koNhr2C2ZvmHmAo=2B>m0Zb8wq`Q52DojYgI>+j#OW6G{e1ONZU1kJpJc+I1_ zzZa_Q?sGuLhE=vJIJk6Y=owv8b_Z6nJ+#9KGZ&R3_%T6%d2wz6VBFK>6&}$)t}H3u zVRX!}3vk_I>Zr#MG&l49cB4fa2HKkktw|=#lSrqlEyk%-+_YW72Y*DU*nSEP<}l2~ zVz%Jtw-2Vly=cc4e0X_t0d+C&ZxDz1n^&)HpyA%zYv2s*yRu67N`rwv5@{<7<2Ym! z2@9AvXU;W{)Y<|L7<~$;ncjC9-$;}O+ry5GF z;jo<=w0%312I2_Kpl5tUi@J}8ZEj)Vj96SIfV-<~E0}=X?XNqG2*7!-_4G>rKw=QO z+0yQI9LM z-7BNsq=V@fQ2m`RSzOu=wq+ijZ48a{{fvr*$2*igw(LUxv5gpy3m0dg5@|2fdZ}_m zzQ<)Kl19|dXWn_UKhQJno%wKSgL?IZfRYFiUeV1w4>w#)P6&o+PKDu-*ck}mljct9 zx-SqBPUFf#=S78l$roJIk+Oz{?iyUnVA8`T`5U0iFk=bIfEoV#)b#WQ2*i3y=2uj! ziJ=LI&7^y$KE#Q%d+CU0p;)!)&LI4Il}yv9*gJd8b@Y}p3|HpJ1h+VuRn}J9%_hpK z?oX@lHq*{bJlifOHT9UK&x_<0EumM+TgC^`!8q~74jwwC^gH^t5Al0qE)c~tvQIB( z)z12xU)_W;FjA-n>&?euPrIWgEYMb9b} z<)ld{21`CNMwEL-aDoTw`GtGG-XTZjM5L8q5S3<@9Qyx zuwl=hC-(MQQLlp&=VvRo#f2i115!l^+|Kr}yENcpI^@a{oQHB4e0wVjU88=z^o_Dx zsj4=Y5B21U%zG1x2cvh+QQL>D^&5TfdVLB^`*cAY(ckqpdGha`7Y4p*g#}z4_`Wc; zd^R2)s$Rp!yDmTp#4#}GV_4Cs;BB919AvwSAP7MN~>K7glnX8U|~2=o&BEG zlcr2TFWK0)W?mkA&IMPU`KaQM^4$!L`A#!{wLz%7xG(MNzV7uuEx`9nM1XG;pb`X( zSG)4l-Qf=I?g6}|t4p6c{osI@+D;HK7}t3kvF4KiB~ zNLlL8T?a>J)*$Tc&a2|GSy>b?T<`)~2MIgEDnf{8yTtM-58uBmC@%J=nJC~3X3ztv z_kUJouIzZf$SqHRFDUhNHb!U{#+Yy7AeAUt!3x<$0*HY=eYm|Q5KJ2I*Egd`B#Qmw zfPgxXxblr2_(sm*5fcmy=FqYV83Bbkh~bO^q(YlJj#|r0@3zl}4e7$sE$LOFwUwbJ z*!H7>&^XUBfs>T|#ag}w-A&ITiQkcHx{c!^A_z#bhXg*r4(}bUaM^&e44_}-&Hf7G)YO}5Me&(T!c0ysLYR#>)BVt-w0zsp0=GBv-lj3 z7nWWm9D#&fRuDj}R0C+ZA_v1#<`)g4U@ z-1rfL=G4|;Ei+^WA~g!HbQ2H!<#8)YKFLlJFFb&)sOse_(`dIA*}~Va>6EfAvoyP1Hb4_6a&fQ(CsYFh z>c|uva82Q1*unC5Cq&e!z?NUy9uTk?aX8;v0zMF)jubo%bv}|sus#hC=>}XmH^6Yz zp`p0YV(gO4Vv=75R}5t1pa7RiLGr^3SYH2QNdl+jaa}5n-BuqtSYko;Sn9P zMAW@X7B%kXDCv0uP0RUBXt5GE2!xiT_|SS@M?E4sI?AzYgzw}O@|{F z0kgI;%0MW46#gfkt@9cT&7MzR$P1QFC1(UVbg)y?a*noY>_ub@1XLqxNJY(QeLi4I zclCQybT7@jOCLBG1PbT&@Z>h7;emSkXq+U6hSs+;x0@lW9^%V3mkG&zS?^C&i+NzO zBH3Fwe=j`yHOU5-w8+no98nh*7tsdGgu}ugb%lI4aHSu|5AIy3ju}K^uHk*z1ImPv zpm!BHJeyahA43>rP=UOJ+*)@^XD3g>xB10n1N+$!5<0QkJooRCrh8XLAA478Y=YmG5BUKx-6H z*H|HgG3zX^dT7ZEWAW9=2Sgeq2bY9Guf)4A_C8cC3I!Mi#>hq-b~9~kQZWQmzen_c z-l)|%a9iN`CTnZxo<2|&@U~>WH1wvR_nbL6WKrPu6hqR+rQN_+M=X7-EJ<;ISnLNU zI?40(65G2GR05l}fgdd9O1WL(Mlf1n2rc68CzoIkKG7@Kni4lv6I_3MDFvpTJ(GvFp{SrrF68Qp7 z+~pGPB4UJ`0i5R8u*Hdh#O3#ovVkB>BB*}b7|&&gjvT{|o}rT55@9YN;B28jabKi?BH;m;F3 z)aDX@fv!O%%VHp=4q*`3qwXta&th6Z26i-=2_usNg({+pzZX%@7_gVyWjlU35&5(p zNsXXT0N0?WlTa=eD4wnMYo>k~YUE)?9H+=txzNzwN`_QzWYV#-1&3*CL{8}DrkTR~ zgjzRGy+^55(nn4o_OGZ)$!`?44Ls@cysTC`pZB2hkViwA&5^1AkGPne>_n;{B0BwT zU1N9sbF;&EhS*8)qFA?h_j9&8kdGz{h~k{0v|Gs_?+~?vF_bOM;AQ~hfA`8jQiXzk zB>>3!!3_W^IQg!`tLGq9tAr;P-y8i~`PPA`cep(;R_-|KxqO8cI!QuoBo$h&PD;r* zuP?4~SGwKF%3^wH%B`^b5Jp@%MO+pN=_^o|%2khz(0gCn zj}z@`M@cZlosdRz;gRy8fk+amnRzV6I(O`kqM<>IbkVzN0L6>&Wq{h_D4zBiEm^VR zWW9iTU*0<3MU7QhULJrK=2B*y7)T+{D4FGNLE|tRzD3=-8}@!p5-SVQIUH@}JKiJ4 zzQGB*gK0nuYkHwSX(2p3?kj-kIIdO_c%#hMCY6L<3NcvrZ zZ!ojNpC%KLBYEmg!3(EsJNVh2moAcK;8Xy6D98RLcQ8JRcAxv5>!P6o)xcJbZcNVV zeP9-xjtKA@A8sWckHb{W*wzc_og`~Ru3l!={2Ml=PQg{3-orhf8_b!bF1%dWPPyud zXhDtfUzU@*QvU`lRBiz=LMh{4*tt`g_MiL03Cxl4Bv=9eqM4aLa&`NA;k&dEiwhtM zX_^0OABq{VsDaW-?ul@Q-&X(D+|`TLR4z`=hQ}4(P$5f&i!%J&GoML0tQwi`E_0S> zfzoL~h^OgMayGPg|Nd?F?^ic^B@2dAo-f$FoI8-mv<;MW9HoKA{_vA08^Qu$VK*zZ z%;|^SgB^$JNHY0=-5AZ@cG7JOdCZX!L^<_vk!RA|7gxtL;JFRyY*M+5vb*QX8609p zPeJHJn!>3)loO}cpN?^|1L;l2$M={e?gBuCjYD;1769>bz&acTj)?E2a3D5>jfPld z>?FT=C?C|(gfP~lb|^6Uj!dbIvEtqvi%hLiYb``1&(^#gJ2ls77vD%5l=8-ZMweIL zFz3pccj=~Cgwl6Y652l&{j>PcQGH#|ydoKX+}x?5BcDx&a+0~>=*Jw91j)6BE=NN( z&&`|pSu|&UTRLCADj4L8;@7W_emKL(`0Yk7Cz6{&luGKE&Rsc`pe*adT2cVqk(nRpMjW}~ z9uZ_nQ`P|H8h9bf(&stFJerE~trFw&jf#Tk-3R5rcTz`)i%{HLoYP{rb7YwZw}`$^ z7a(H>KyW0k3Z{r-%;5ROrqAy*t!V!s$HjyeRby3;i>S}Ht4>r*ZpE`iP7f9ljmDo|o(8Cg&HziFRKvG3 zRawfZj3d2W((FaES*wt4qpY-;7+`Tx7w7ySE&@4A0UZ>CMf!)3-58|7HTZs_{ z!3^RvRHT|eJM!SsR5xC6$NfOcvDY7-*#?^C34Fi^td(eXX=wg^brH?N@AoyoTLOPF z%eHN8cq%Rb!17P5Y%$lZ9BrSRXF4Q(4#61`VI`rIRZo5yrOHu|`PX42oK8fxN;P5m z&BKp+leL$)PkH`o@4>4mr1&@SRy&TOedb7zEFJtQ5Xvm9)Pr%L{~NPyxu}5;wszUO zcdti${liBN?@4*LlC-IFTXyVKJ%f@E|FmySq7PJQeJ7KPb!RTgsQ-(#fJJQLqpx$Z z!Vh}<#nBUv@ru?KNEQ+>?=IZy+>>+S(lPd)oD&q18!;hq@|i4iza?gBOhcQ_em$%n z7j)>*4ut5mC{2g&bunQ#@eV~41err{aAjrmI)E`od_=(T4&9?JhdtjJ z8_njB#BnNbzL(ajx|s4LC5oSAGWnYTRPlrf&yg{vQy!Q0lqRv_gdi-Sl zcY)6C)ns)jhyI-F&1*MssNVIU#uBRow5B043iUpKtoBaGHT$uDg zWFeC7;?xX=ZN)ilU!#oHKNp{z8d_`oy^mE&hVzNxLXr;ARVzWirvgJukw7&%F{fLw z+E`xD#Wq`a#>Qss@%bk!%Wd&P|JzR}7vrZhDdRxp@iE zhyUS-9t5F6=zt7y73B7h;}}mqFZ6npWwd0A5|<;*0cRuDNqO}gJ_AaWA>+(HzjY3X zja_(7oMxN&Z$y8{?_-IqdAq#jeq@!Q3pt>6BC=u;e?{ z*_#!zbS9ewG_F0ql7MMYQC#dQlw<&JZr>#CPhgPyQ zcG};5{#=c+Xe=L8P%&D3M1>MWhsv#0WJmsx?gV~k%7Ts-+%4RNil4)sBDBA_0t1Ne zXF>A=iIN4wAgSlEdODNo(R)ojB(o45Ih7h=K?9frM63Op^{~-VgBx%MQ(lWAlSVWR z7Z)fz_r}hpn-SX$(;a5Li}jS}e3z?yj)%vK*nM=Syq3*qPUQ14 z{5BDVZKP?`F+R%y8(&TigCBdTidwPY6!!1(ZWbR9(Axf z&4Wy5>>f8^!cEP;^T1k=N*sB1 z)35$hd*hlhUn@q%mbm?@`^~>&qaMv38*e)1du)B!YlAlV=WI@gKe6@pwta0?o_P9l z|K&41&Lkv0v2l-1*kN;ifQ7}PxHfZ}+)`0VRdXmNA4T(pu}1H4J(Ukvm4&ol^iegt zeUFhZ{wf}Ac&_;86AZG?6Bp)0=AU~ci(k&r4l8N zz+mtN<8u*aZ#MIql2_1JrHP;7$f8abYy}0C#TMJd>ghmi!NE|=N**5X2V}sD_`{rk z-PdQ@_Q5G1(mRWfgszMmxGr&+mi`lJ-`_1K=D?UB~5S zDeBw6<9jkY1sT;-G%?JR{)8(7+az}wvq9E6w|YkNfOl6fFDF-KT7xBGj(PCfX>=bF z$i!tvBG%Sf$;%zk9YwYH?^XUaSzTG|gGBMmgf(KaYX#V7TT$Vl4Xxv3lIy@X)_2_> z)2az}3^57LO)lnEVIPR`PQvN$-YpOETgo>-bgRuNEE{0vdU=c0_8N4*&RUFHTeC(q z>O4>@m(jHkdgEw!AZSsYARhd{H0atyWGxpJ{P5dr7!+tn8 z9*@piK4!||LY@W_8c(fmVgcAM!@MPl92&4uixxBf_tTgDMRd~IpG95yTB+m~NLo+| z+AFY$n}~fRJxpu(@Ms-!1g5`mzPrmNF`2uGLNG8SW+V{^NDtsBb`R)Uw3v)*M{ELO zS)vp%LoRS znv9;t4|s$Hyc%#;%Sm1Se521xvFLnzc=fj*viWWV!N}|uAjY~hQM8H<=)pM)rq})= zUz=WTHyj7k%{)mk){qR)RL1ntb}A}wIo~bHizYBb>L&ovORKlX!vCiNaLE`JiADgV zdH=P;f8Q>E88BzTBx%SBKrsEGMxU?#WGeD%m{3uq^0zHidv!A~jjUY`%Py+4Q4FwV z+twwL-Cqrzmu;YS{Zj7A4%GQQPTK0aP%ubZ31e>!v}>a^fK$5T{^!va(Z&ONrt$iK z!hLb#UuP-_WX_}H6$4SmSmH%72w>$!ga>K6@6v`H-2mc5wV^Y53QLZ{k{tSHuV<1~ zey`m8NN8AC?aMJV6n#0{*7?Gr+H{kR%FB*()=QMz=#|PKW`gujCv%fVTc9ueMyY}f zQ14k{ASikLV1V^~C&!AQ zqoiwQKv)BLpISI-xLgU1x@9-Pt0+|u7kqE3v#T|~JP1VWXLG(0(23X+5P0}gpVj_y zKYn?ScH6FZDC0n*gHSqRo*Byhz(i`pyo8clT*VIa=Tjln3@CrmRu~*c#rRU>I56hy z*>Zci7nJo6SrWUp@^y%njG3S^Dd29$fZbF~)YyU--6VW%n>^s-d#7bNH}_?z3-+cu zZ|&mW@L`}6*GJ5IxW<&K`NkiS_@(n#;{`V*+FV@XsB@lqPWkh@Zq?9cIKU-?Lu@2Z zmBK{G9id=26&n$d@%Le$O&lGy-|xD7KikPur^ojK!=iqe@8U9!mws|$UNg1P7mXKd z4IB0n0QuRl`hCHqknP<>K#HB_>{4n5LksnKt0Gv>|cOHMj9&ohsHv4b!=Q* zkoPVZcX#qE5~2o9>O+w+S}oAHk{2w#Rrb-JxD3*MUth8Me1ODX&?RwOk+iD>7>%=qsdO$gV)wRm?gVnaNwN08jwPPb5AFbL z#TB2kQxps>{eC{B~BI5 zj3f%Xn*FTP8#gwV4bPf*<9xYhR`1fkG)rp|Rg(sk)j%&FBToR1OJb5Sx#4To#QpFu5j9*`*6KFd5k*Z(1Y92^}#YOMWrJS_6rGatjuP_RaY zFVT4zWu8TPX#?a#3Rvk7SSlg%bNE`5-#@ix%i>+?#4WRkVblwsG@9Ogi^2LokeX*p zP8(h?z1fn+ovf7>bOc!xIwmY^iANWHAYO)@c6E-Hciu)*H2!4!FKt+ZEf1zYIB0&r zIXp;hk1|@_vBYRVn?uz$;Ky<4Bo%e&+w;c zMxdooA6`0-Tr)X=u%-ZT%6uCp4KMvxXzg*MgY<$NXFEefZ}*%hP&6?j@Vkn&RpB80 zNoyW)yl?<0VA2MxB02W{>HC>Fr8S}Z_v?O*J7Ly`7cOrPHG9uU=h4Q@GLKX!v|Oo72bExd)CKSgwZA#P)!*~A-*DN^iTfDHoU zjT-$A@*rWeU=e$(rqQ{4VDMpUntB9JR$ev#$lxY1jl!)jUFEVkXQWwV8}yE{w7^Cs zY)}x*HfcaKOp6uH*}FOgj5mSeofpogAR@F9yC@%g*bEle(kb+ zW}BJSVO`1_Y}+=|XR9M942_i}T=G-6tZ?6KWGx9N@#@v_83+5yS-rF+3xKv!rYxhv zF)}sv!+R{2LR=`0ydD9aqtf1K@uTr&!N#hC{7Y;K3P(;$h2jq%`Fi5kTUT^OjY>mg zKdYqa#})k#!a@$n>}kA|$#^XhyiEWiQC#EQ8|PC{%G5qNl#Ny&^K#uALuax9$ezZo z*TX9?(;^a~mXRzO9Iek6h9#mNVQhqj1PD&fI18Z-+xC)Dh-KYT1lJNm%YkZgQ0GhJ zfgCsQ-11wzFf{`@<-zWn%Roj0($ANKq@#qa)b6}(!Va;Vh zoay>F8|J|?&58mqX}HnjG6ucYr=JNQc}t3(lHC~dgpK5x(a8%b%R`mb3ZdGHJ54uY zwhZ4R?6ya@ZtJ|EOX}==-#+t73+Q_Ge%~E7zj#MX2Msaai5x_BJc~#IeYoN&R9~r0 zbyL(?H6p<{Pn<&H$HkW3;G4jCHAmir$i>L>{&#z+P=I^v*vo-57LYX4v#*uLw2Ei%- z{u~7z=zFD(EU(WNJVH3%>)bGsbSJ6}Ojkn2v;794I20S-Xtgu8FD0~hq*(0 zMLU{cSIunke_0KPMe1`h%MeOXqob7_V9tc5M8ts;_r!zm2$E$|H*LwXRXrnjpk5HH zOhh5rf&-qf+ziAD0aQrEMp;~_#%VuiJM>*kzWuBCDlmOJvxt+ce~dlUAH9I!4>M-8 zqmGBN`{(k)xjj4y+T%CfY;LJaDtL1%fp9nL6P(T(x(?uspe_J0v0x)GsGvKqf`?CK z#1NP)E!zh8--^`$2OY>)m1l=;7iXW|(xCP^O9rLmtlR?mDd-mzqikc!G+uxDWvs*N z=fApZer!f&D3>btbr-$W9hgxZ>^)`Jmy#2E?brMJXN=#~XAEr9j95E~b~{nCQiNdi zJjAB2IhMJbqmGmKNL*Yi2DYDApW0Hs9%9Pj$3OBo{zy1lU@9pnEL7^+wd;V9L*ZT3 zW*^zByq`iU>1Y%jE5jYzQDFS};zlQB2S6{=H;Cwl)3PCLezVTQn#qVOgk^vPA)Qvy z?XSn{--BwI-|UCNg@Yi;WhQ^69d34D#tCSULT+%@VKODF}5q;0P zv}uPN^9(8rU!VG|I$ax9T7p&R_z9HQi0G1MN_oGp^Av0`P2qEGat@q2P0Y{2eXgJ# zavfS)*5{HEU=-M^vZ~7P&!k67)d5oVd+kij45LU_hsUR|q~9qYv?{Gbn(*N;yXt&- zwi|}i@uL12KYlR6>L1tMb~J;m>sf{r(Vyy>#UPx^%#@Xbc@Y+>j%OlfWOjP|`2;{5 zsNIrs@ENgc3IGJ#V;VLr!B#)%G>sz{bP){g^wOWy2O{;vWK8yA{D9dR8$|Ockdkl) z7}=2UjTVR29f41m4=xpJZF6U0V zxx3#4hJ`-d0;BwrSD^46x1qt};b90xEEa_9oU+qMz60!2HnVfV^y+dbh@1)l zLFN;3z2=;pBiBig$WcTL@6(_(?hogdq+{TNl{EOARZG8%4rDg(jqu7PoNOV+tE>BO$gDefz6hy`9xLOE#rZgH$rED%^CKe4V-mXE&~DgXqhB5 zA8zHwrDbK}^_J{fa*M=T4u`QyA8-tub0fP(LPiAX01xUGGWi2JrII@%qDTo{;Ky6~ z8%qm>tT*sjv3wPT*mnO{RYcm5DpV z0t-*U1t4~)Lu-GpBI8@hRm*9Qv{mkd(nVP(L4n+|D-mfE^%N*m53_%!_Ij0xXkaW} zLJ_1=Gcr*{pnbkH43hb>mAW}Ycf~ATv}i07C?FNpY-SEch;E#vGaK?s@#M6AZd)ph zT8OZ+a*;{cu=2RThpqXQ-zptMFa_r!#%Y-fMLAH2%xLD7)g!rFErIW{wGdvQH4+gs zcUL;kcMDHlLWv~T75ITj-SE;u$ODu=ZWPrgYg*1s$r#}erc_rXYegL#ZHeddI^dmL z%9PX`?;Us;m3~uQJ|f&URf-XH%<*%Y=dB?@nL2X0Bkh z%tR282lUU+nHi;xJ2=UblUAP#U+Qus&*Lc*L~-T++g7=|q&7=lHK;pxeH11GulvjB z?^8bK7>fr>lDavvSAV`|NIidpzh-EDT$Y>tLO67>gY#4&+GVINWYbc&W>b%Od`8u> zBx9vn!uVwKKXU69w5)XGo)3>9(P~$#0@n1h!ln6jdO(uaJ_>85t6$u6opQpKP zyGO~1Lq#fqg}FzU&M!>$o3nlK1W)hi=U%FkqQiEQxKm!dgjC5Z1I`3PiYi4{zft+v zMk)YF)DVFVOt3O*82d`3#-6|K4QE1hL#G(4*l9i6Z4+HCDma1Q1INcG3pg}@k!RF2a{io z`vkBls>P(aa-A}45k0>IWuUjY5H;RxWP;5l+v)KW`-bTEZX?km%%y6nYT3iK@#M!Y z)2I%GUb%X8?cSFSFs4ox@K!)#AjRa>T`Y}ZnSt!@Q880@MVsDLU51BiBh`$h|2VH! zKrRMUhFr4J%_2}d-67WZLqd))5n(WKnMj@O3z>k6!Jk5R1UB8km<{oGpdxy)i4nnJREK*7C&h_u2W@B+@wXJ(U@3;5APpGn! z5)-{Xi;ldR4fXU12s~xKwVb zB8jX^(czzzH1gpL1RM$!IT}U&+DJwyngL~;{{#Mdj7Or9_T)# zw&lCazvM=-U;SZ%pJrF|K@O;(M9<9C27=s*OOlkK^G|0yE_-{&E%xNSyu5UT5Kg8ZJxBeipJaB+0OJfQ&amCA$p^K;)~Rx^>K3 zbNMz?YzqhoajW6YbyUnCql2R8G4F(0gOc1fWo4XMG3fbRp65FZV(-lI!8Pv?A<^IN z;#uSBsy5ty3ovGwbPqbEv)kVW6&mAY-tqkSH-nB&yTuLNQL&ufcVRLpgg6utfjy!s zn2A6uc}a1Lrp=l;b0fTCm3n4q4;nOw0ovu2DXO~fi;B`P$URL!2R#&^RV;eT3CBd^ zn#D!%h!arUf!lWMc$4@HF#N0UzH@cVF9;LKg_16=+AOs?opZ}qS*Yw)Gqr8fFg3$kt#I?h?u0mvyg5>>0iDg zpkDH{uea*$D{s7xaWW19#Nb&(mrkoa1JVt<`rP1oS^iM_b-sEc7?cU$6i-1Mj#b|5 zeTSO;gJ1tB-s*UjryfQbd+zMnmG6GLJk=ZFw0+iPuMnjI?1zqM{$0Q_#kgm#Maiv8d(~$4z{r={3;va9) zgd$FyxQSWeQkyFLLJ}LX&q$**=eMo|XVtw1qI5-kzRA>RyvZIT0Q^B04$?<$G$vBn_2$uCBKc ztL(dSMK4;g^e_mz>XMU(U+s9h-}x>NIUT~~QPY7b>K8n4?lx`G#C1h;1Vs*TOFZbw zg-O)-XO>qFN`F+F&#|13pY#VR`vNa0V`lRub&(|cyNDma!ihn8&tn%&PQqV#%iA>jsuH_Iq4Zzw*CPHFcm zI%odK=Kck`R*>yvSyJ1`#*`woNF%g7+a=a^VqNXLv}MH;iHm zU)&~6kK^aUH_o@(OKOEhVHC~7Z6^0+a zd~si4H=!ITBwuUteiT1-#wL52py{M>8_O?bZ8abJz3gq{Gf5e9q2-w9(Py=;l=ueP zbnk3{i2XoiGD6oEG_s5$|!v#>+_)E4ZmK9kA4^|!UsTy z3iE)3@Onr3#aW@mOdtcG4dBN&Dh4G5bz2&xj%cdk?nIfcq!5b`b+DaE#87~E=}bqA z7*RkwUcP4qt3Fk3a2oCF4<78U*8TOO=2utWnzmECcQPv=IS~#5k@Z-L4u|biyGOcE z`BV``)r%|jN&k>j7<7i$Sbe<&^kP1<-jo?9C++Dl6{PgYRi=N7PMF#S@x)Wz z*{HoroOE4S$_(LVl{A@M#@wxIFAjh0?X5a%)!i=^bk*eA>9UqLj@ISo{4-|m%5BHD zu~)$3LQ+3zmX2AGxc2v{N6Ep8(yg2$$toUyR|Hv{08yZM?i(=9l1A@SK^sKZ&H*S! zNcnG5ahTC_WPB{oJj6J|EhsJ7Rx|qM$qoe~lm^D@UDTx8|M6^I6JBQG9pxsdHKc$; zZHZ1_Bjj5$7gqR*6BA-RQ%n$R0bJb6$w^Hh^&ts~T1AED)s~$*hb{NmseiQcsPR2S z*6Iwvh%KjdMrOR86m~LZE-r_D7x|rZ9U^h0^{t(CR7oWpj*^2zO^^E$x6L>I-#eTs zoW%?%F@@M7Jk!kSKeveiiv1xfHH=vHK3^=!0AI8v8W?BF!Qye;#GIj)M{z2LY<$#8m9v)P()=nA8z?oXSdJYF9yJ6Y2;N5Ui*8srNmWj+&K)`)#8ey z(~8dlygfM#lM;9Q$iDqKd(_rhz1wt$wtn_?YG}OA!nsA|?{v*pM90M3;74@5GxCfHhA<1I{#1AQAZX3W(VRiu^aagFUUE6!&Q!Kcc~X|9L!@@7b` zMLT8XYsbwZ&8ojTGwsWf1S}@PMpJ*OG^$7F#!i0fHlFLCAfp?@+@IV~+&bN+m&%rX z_{x?nUhJ^;*O&Hu5KOIe-|=YY^4Ae}d3a_V95S~FH+sJ@V-C+s^7M0Yb36Cofknl4 zEBjS`N^{VMYD<{|hOvOAOj4)P>ZH|K=WDueP+?H?xJ)p5Kc)Fr3A3pDsHz+IGVfws z;rj{G7oVf1I!qQ5qg|i6j{)mkjwO#UH5#$M6_4<`?VH(ep30Vu2gj^EG?D?RwV6_Z zqpf%**4!*6v0gru3{6|KmJ*-~i+oFM+o+c}j?nVRgOVQZS3ogGMFS0421@42<*5g{yL zJc%Wqo~3*0r2W6QKsht%oe{B=x9hiR#wpTaxwsbKLHBfr3oB`2g@-#Oy9J$g+#MX;{UKBAr&s)pmxxqrc)jGW4ZFrW2k;VQ z;5n3R?dM}bx3^!p&OQHP(9^t(41e$Yt16Eg;lU2$*pw6+_Mv34yaPj7fcGwc4W-Dt z%Bp|&9Q#Bd{L_8|2E@*)X8dg`xO{%>FP=j24lAbrO4Ij-N|R%2-&plI5RPNR3Z{&ghxVqR;2P>kOVt*&O%-=YDutsp3kHna(z?skaF5SKPcN>1!WRebky3du zYC`|7heOH_UkEsuU3`uk^DKZ&JbgIvcp*P@mp*9t_x8b7Ru7kFW3*j*>HnH5pa@== z=4G36I``(7Y+0|O`w09FF~fS2`aRuIoPlZycp&JW1UNF9&E>)wi@ttX@FX~vK+a{Q ztAWxv&c!OjJjk3#9~>-_Sx?r76Be3-$!G146N-;!aXg_AkRtaZ+xl;Iq#`3M(Is&9 zFaMp0&S<_G@`I3{dUe-aF3bK^COJ*1V7`^NHO~~B%hoerHp0~j10gmyL&n@jjW5~# zT-gJ~p#(rXma!i#`hGWyO!xf{z0ontdvk z9BD*YVgo+-{N(V#T3R=_2ja+^k&i>Ay>4c|8OvsF+<8(aPKYX45}m0o85cagc6eaP zbz=x`%&N(+Iy^`rLQvQMle*@xQj4m&s_ns-7{il+P4|%sB3MpNb zf&J_*R_>prlB7wyb9Ua{PKX`Gb`O$?e>2a{Q9?`nffgW2CuO;pZHi(iCVucE8Px;e zqS_*H<&0B4@#*AB;DDX8ec8Sk;wF885K^^^M?tdHMK(CaT{C2I9LX>uB?W^xsAuTW z4om_2g2WZiUj3oIU}mjajq_*}SP3kOfU2%!mkTw|)FCCOC zGrdK3D*&*h+Cxi;rG{c^EU5vxg|#x4T@qkH^<;NxX=577i)(&eiW*<~0o6{@+|zaI z)IkQe6#`sF0SSi7C%EYDtzToYf2H?U*1d#)K@tdE1gv1G8hkr)!re}h7EQR@CE3+8 zbLWcZs~Xbl3U|W8@<;sc=XSoPsA~;gjZU-+qkQz396=^`M_LJ=S6^|)Tw_RtI6VP! zPThZaVt_&SRwB*D5v@>&dIf!`l`LX( zoP=acR0*XGot&j=_io2UzQhxh=oIuBTs%L0={tMi(G)iOkNZR$L@NMxwbosS7M!p_ zxyWc5qI9%AHWL_*FepJ75z-gY8%Sme@Zct!pS}20N=Ke)MS#g9y-Zd8m8KaML)Eu# ztoqvr&9eZ;nz5PtzN|l1U0FW)cp7go7iE|tVSYH_h2HuNcJlRY)T@oB&cRXsq=BA! zaZxv_w@M}_rm~*b{{H?KjmHOy;?&2FtwjpYVbmD4Q>wf~c8?>KgnUYI24g?wY=Aj! zr46pO5enxR3rj#n@!gAA9WrYAviZ6@Y-&TT6$&ikp5=&)Rdb^wqoUSN>wUvlsjiOC z6?B;pDsO_8b%KzS35h8+zpJ&5S1Mr{k-&1%#K`)jfE6t+DaB1m=@p6uTe*LyJ2^d$ zXWWLF1*G-^UrR%qG%%&I4(+_i`?1Q&yu?P$o1X~PqRH7D$_bT*#7E|EiaU}U{O!{V z1NFYYYF)8mvA&uiPfrZ}L|#aEg>Vbpg8Z9_;VwEy+G)E9qRdquPFq8LVV6um6Weqn zt%^Q*NT3iN7v4+d$+d=5WyPg`85q%e#u@tns+sDePj##Emx#h16!=g{&kP;Op8Fuz zKdDY70-~p@4kXtGf?YZam-Diyh>7M~p;QF&!y#w!QL=O;BV{bed(DV$K6E&{-}fr?dc zq#uUdXVr}5=;O~%v$K;eFYy{2mK{bd??-Zmx^g3n|CAg`RP-qv+OkqzHVM?-3@!hb7krrEFvsRSaNzev~>u?F9^55_l*n<*Y$iexUkWFqB8S(eZEP}RA_~hono4B_HD7;=9 zf5gCWTz05Qw;}^^1XIPUkmuBMDzMGPAgv)PTk6qLzglP?NZ>wzqPQYZn?d>cBTi-C z{-<>#vmhjR1jir|2@vfvt&=3_3O7)D#Wi#$Jb;yGtS;8OyTLC{zPq=j1Sgv0WXt#P<7YJs|iV7v9-|75>rQZsm<20xjU`GeGLgo5Y<@ zkP10j4RG*OkRPmx{AhmLE*~E>_R|-|Aews?ZhjRQ2)Jtlg?J#T70E$Nh0GvPROT>v zjVE41fAj4m{Dn+|WdV!Moi%GU)B`{PsBRtFNaBAoeJ*NoRil!N)>)dPMCU3%iVXwv82g4|Pv4%3~+@HOaeGn#+&sbLY)-CVt{UJ~$pfHt0B*Y?|_&5v42(qAGd|H^HMj#g~ZH^tHTHD+quC>95>L;GK|KvoTWlnfh2Go zwHU>WSfDulJ%`_t1+#qlo8aLxocWLXmS;mbVw$k{Ru3xILV#Kc*Pv-Y(flfS2p>tI zKzGeGi)=z%FA`nxpBy=SE(Nu6j%J6B9sd(lD0~ssNM=7ZISQ*ZHW1@gTF3$A<(2yI z;oj(xC5$XR@v+hIGF}z8d=T0eimnS`_V0OPh%2QNX@rv$Jn3|UynqMYt<7aOJ$C2G z_H+ZgZaeQMBu-NWkBWAuEe{w$!`0McB)!d%cw-+i&eVMS3+79*Ys4;(957AuOv-vH zx#j>7Q7ufn0o5<;6taD0zc&jb<_>=VOfDA{mIUXyheVj`=GGMYYQPpJ4-avll4d8< z+V}_9w5%el$1};%A=7|j4ZhOA!Qm)cOGHjohxBH}U&&q?&oL|a91P*@o^{I0%lmw< zHC-e)qKqYOig_bT+*yd8;lo;}>WB_VA(IFZ2_*&BN5Z+0l}rEAds1ZwSkpyhxiiMV zv+K;0gq<)rf#o)Gq`dHN8DoB55AZ!UJwNKiF!I4C%JkT)XvSaYM_d?fMlw zq2Nf0ug}Vsn{v&sFIMcJI^VqOdCGHs_pTXBw4xA!E}DLf6T0^^55Vm-^3#`Dx)>(% ziva9JB}$c2weB2+7{}UXsziyUvh%z{?RnE`oZ9ic%us4Undhb2Ybp!vX~}f$YcDcG zX-|5uUWhGDxrv`>({#G79JqqMG6e#Py(UFf91%DpbabM0VopvTrhOX)KU$t97x3MW zX^_bru??pRrdvC__kUP z=^(5&ociIUk<0_RD<%yz-Wn>6`OhD#MpOC@w%&kNJ&e=O|4KS`Y<*d?^K;?B<-IV< z4l3h9duW%N(4DW7Vg9J7CZq;Zk^N zF##(=NBqjC_c^`Df;cO%TsTS5dYVPw*RT`U>1Dp<YxZh+t>#Czd*ga_l3MA;|8}!=uZ}{OiCe`0=hDNju}tLS z_CU5lNci2J^PGD)I0L+4c56Xx9s4sC^g8L)Zrtl~1voimDJKrxPm< zDaqx_-Pk*y4c!_=P5FaWv35yyc;bFr4%4uT5v=pD1=D`l@d|=plK8auDW6(^GPI(8 zK=q7TE4l|5|#@>i*u#GKE4^r+DmgPg*IWuGH&ZfJZYaZ*<>5_y5uZmzDL+L6v4`{IW~{g@|h z+`YiL6$T|bp%wi&J1Fh!iL<*Ha!L*HQQs~nx_ir;lg;r^?pwe%F7=?Y_RN)_r18vf zf4X*$OZB+6&s2qGk~D&?F78jih^HRee@YeqeQGYThk9 zzu^#HPvl|$>0Pj#`eg!{Y=!$<=H+}>xqJ+3POQcw|iCEpoR zV$X@2KVMEgR*8`}|DR||0j9&z3QV7Trfb)p(ckZV-ITzCzxHB$E(^R(FE{pwD5y%D zP3`Osq)ykSbed5%T^qfJWDCI**Wp$b&lQz2Do@$$@;?p*+mDH#h%Bpjo7?W;y{*IV z#6R0U7>SyQwmr)^X6O;F5s~r0)8a0NLLBgzDAXwM4;~savG!;1KX%5NX9a1~rt)F( zf9g-j3B)I(ipFzcpzb6LTf!QDo6frJ|>$1kh*h*ndCq zc-X0%w>t6glWc}?9LT72Zt1>0W8Nak=cZqK@*jzQL%l8%cQ>c)g#tS+$<}Syu%Um( z)tzcD1-&B%o1Gi!JLrGk_gEd*!SU(r9Y_SbFe8oiEPQw<(sub(0n4lVoLjJh_JTtC zV&CTqaiigqaRkE&T-!<)`ccM$aeCrP=C_aie?P84eJYgu_u`*{qj!h)pem8*{)`O6 z*m3~dG?cS=EOHaBc`Ng_#ZT$)UxbiYrpoEqRUG*5Z8YjO)#}XQ29~pC^}n!Sc;!`j zq|+R7*d1*-5Xlzve)R#*Sa5K#SdC))GfjsMSbyo#&rTU|3|S;v=v`HMAfoqle zF0CvWM`v)2$wYum|DVO<xor*u z0Ymdza&c0Ozof}0kgIH&wmm&!U1AIo^$MCKW{Lk|GUTVWyjQkMJGUnLxsRdctTDgq zuC*_SAKv@O#c4_tZUmjei&vmF*UV+!n_D?{b3;ewOw9@k?O`}~ibm7>DsAssj5Uo@ zRvI_=MzGK0y^G&dfQ+elsClu{e!#;+flEdh4t!r#{Uv47!6k>UOq?E+(;$tIDA85vl*db(0x@@d@nk4z*Z_q3DtwZ{r8HGcgWR-%aYK=$h7i zu)yRWmpxz0gR4bTYIGvUW^MrDpW8di*U^O2OhM(&mn7*6|S}%$PC0c zoN)&d%D_b5=9DVASCq6b{&5OP8YrO(m0RBL;%t_GI<-GNz|D1D-e_a%Pv^s$lCs5k z>kh*1P=qm~FzQl)tLLvD%bIo7>%vKTotx%%$N&2%Z~gkaiO3LP;*J#A) z2AnKR@EMTuqcnQip}x8MKs_CqRsj5-iZIXm0d$4@ zK|HJN+mBbSCu&+>8WE~)s=qn(HK=&iI!~>A51*TzzY?=*QRCeddid-qzZ4Jpy1^Z& z@6EbL+nS*_oH7g)PIee{O6-q=9?!SC4o zGG-f|KKpY&zOI)0lQuLN8))csmcI3cw<2HPyyX3$KhN>%}S z6sK(xyxuK2L*NP3jtm;eIX)?Bd(04;C^6j8oy!nys(YSge}YK2Kn6*)iA*j;ihy^+ zVcxum-ZKRwr>~Na0Q%<7t%s^rNrCHAQIUO#BYYE{clMk30)Yp`zyJy@y*uw}JswMu z0yBeE4x_R^OPqk0*YG`OYbc8tG*}5|>>CrBL?@#SFj3pr98AJl< z4DXYtwclhDWdt-%=Migv|7@N0*D=GO$tMKb#(O64FXiThK10E;#j;6#nf=)WnD6Ep z)h=EB1ryUblXd&HoX%q7AsjsL55oqM_3{3_PYbXLaY=L0o6(Vq zMBOx_TmRNzw$sBW9%W~Nq~4V9bE>|VFxP^;ZfL8$EDp16XOEP1jL|?Z;sBh8|4Ra^ zX|>PNrqY!MyzWu^*<5?u%*q>`(yT9nXqYiPM=?w0nRf0=tXE$awGl$v$k=(~49`SglwMCVv^{yLJvrB-l_txu8= z=j*g^*#gYVAW@kDj&kjW_}^4i>Od8n8hX33JZ=z@Xr@F zYs&ehX5Zk;#oF?SP{*nL+>p*T5y%{Si)*G`SMhwa-E0yUY&pE<$E3wtBkvVS#5cIB z3<&)IyC8<2x6dypM>yr$;#)ZDl+l6%Q_f*Iam9jfZ5>%M|Ic^qdm?x4-SBymOrOhf zV{YDUSEgEWv&jIeEKTY>bE{W>_u7?NiEQf_vM(x{=w+#G@1@ZkNBFk9; zE;@T|3+fKR@CYe&;)2I@coUeB=j*hqJzRorr!1NqKtn_o?iQkr)LBvaXumc;c05-X ze%y#XDPQ7nef*@VlD!CArmgDVDT!N-ZCD5(DsEWJ>@7KmOf$^3L5}pmXU;MGHaEIG z3|MrD(SP6VgMNrM)hg)%4HwnSENCd>OUZjf$Fu6yr>_;ynkt0B9slI-6_nQ?zwN(4 z5P`QwmW+6CYr@2d$I#RgmVQGL?GTfi8k&s)dlQ8osI{P|l8VDWZVGnt@n1MwZtQMt>_{lB})Yk*g1i)pjb-Ybsmv+mKT4rWY+ zf)1UfXCbHF_c-Gt0!!U;9>NTgyj8&#;~D9(p5F(uB1~w&yrby@2M-oE);chI97}VY zosX9oHJ_rPQi!cq`gX~HBH+S_*wD}&Sf2UEf(kGX#j4V`tML-4N-mMUgxS&Qm}5y^7p=3Jk*UVXVKSp*4zij00Uen z|6D32S57AfKrsxk8z!EcR&;?`0`!nC!S0!cvL&Ku{sBUY;8_2SveXoZCZ|d0jz8<= z^PTgFF{@T~v@o?c$7&TF6O`#pwY}Ea8uOP-e+KV#U3xVXgkNTUhyWDoNPEwQ^J#oF zKQ{Ory0ZCC6HiAJX?24B2R1eUq35?nl#KZEJF-pOvO@j$j?3Mx%~qcOx8688fBwC?c5TYnCvKrT?!P_n z@j^|67win=zv2J)i>T{5v3hP!f5sMI6&oNCJH5Yl$4x7~BV93{=o+~Vj&U=cj00t? zJpTg0SlycMK89~I#ZrIu_m8G1z5^n{AB0i3aCb*177t|XDvB$r-smUkgbwnLS;N!) z-8d24RG+##Ic+#_;DAn6CkhSF(}!OFP@_34SkMgi2?Auo_xn2~cv=#0h2I9I+z>eR z$=@IvgblpO&T^7Wa)}&6iBJ{Wt@h`iK9(@ol*tEfMpD=KR%dKli@8!lSr~}5859@r`S~^64rd9QXNx$JQS*po zYl5zic95B~%Jq~`BM5XVhgixXRJhJC+QAM?C6}cgAk9Ny}8*XDg zS#YQN{7^RzqyqehIAj&`|Ba7;yc#<1&NX1d!uRiA%qa@~iWtr8`@~0}uv}DWjJV?b zsz*(Y(7GM+?ZA}3Sw~!jqcGTrwpxs~{|{e(9#`|;w*TWRndjM-ACWA*9_Vwvd!2MN*lE3>A@-WC{@?Lqf`szRz>5T=(bq&(Gs}+>dKt_bzL_ z->=s>9OrQyC;M3lro(9|gmgqB9g1>_ifiN8FGK5bK2x5pP#!t0C7-VB64LnAj18Iw zXJ_=v9oowG+)n)PUlIh1rMe5ZXG__Db!i zYHSSaRo$*YJya%l?%l(yIq*d(H<&?2j&)5JTp6Sy=NQ4BGVu;R;soj<4l$5=C4shC zY?D0^PMB~zc%4{*Y+>*Tav0;hUG$RFA){F%0g@&LFtpy>D#OpgwJLwBnfZ?g#O~Qv5xW~WosOHmX)x9+kPQ-Zt$SCiLa^Tf z4jR=PPGmKfd%QMUyLRxrepUze)qBV8#@!1Qp5wd7hUrffb>ub;3SrntbG={A0==X_ zLV}(*N7Hgle=<=3+Dh3b!Dt^(e3S%ucbh=c>D1Ksg*8Ir#}_pEGv zg7mzxp%40diHzg4x_2KJZUrGjoEh;B#jZ%)(}nxP$^FDAIVwDs@sD}IE;OveIvfA zN5E>Za`9@?lknAqBL#ERLDOIIR!ztULN3HFB@Z)p2#zfHV^w?$xCi^b#N_ z$-##o4nr`=@HRH-@S7D3x`kXw5uJTy85|fyQ2i;aW%V2bCVF7VcBAd>45H{1gx|yS z48Yuh;*M&4(yIans7aS6xvJ`6*Y>?FV> zq#J=_bZE^?>L$S7;S2x+(_1l06AB^GP~pk*6|X3&5_LX>%;f?PuIya98m;4Td@KTo z?)iV-VE67*)+=sjWNgM_%ZzFZr zMon>KVromBPW8>7z_84M0^8D?{+^fhKa1^TtB$c#-h{m78W38=nbN0Xg zoPSFLV2Ed&bEf{01)0HHpDma-Pe`k>sY;R8+mTq96LbpLN>u590)Z#Y3gk=>5et~i zpI-T@uG9ovdFB*}OCGnR+fEUR!qO*aFT-{qcxYs>vU4++#a5P}otWpF-E`PwDyzSx z&7<_nac-^*NuiMufd@Z3OiWvQJeH=@gvssE6J7N5rY`dMPjno-OX`f83P=G*Dl8&6 z^kVMLH@18?=<7VM4*8sDfw%Z&%h^UqA~fo?=PItM0v92T+{i~dM7etW`0+c=FZDB6 zhQrJ$8IJziBM-FYW?f>j2+c*zTOH+7GR}PI(@l5+;PfFDxws}_!`{57b)wmMIP%*? zHbrYjql$aCL&dZ*NOY2^5fY#S_Is3i$aEaBSrA{EY-&z6)3(FQ5(0%7zLaE{YF>W) z_+0K&6F)1mdtcxRImevI_x+cc{hBQ*lhfzU72KOP``({NwBR$Tjb+G5J3dYvH%?u_ zjJTSD-ayLfU&S7k>I(VVU3Nwvjcrn0jla_*GuTkJ1tx7bN@l4b;jfN)No8r4?cxpw5l1F|{bjH#GU0oWaA6)O0{)L%bV z*k}0EYbDl!q#s4up5eYJwuz4SC-xi+_j3UcGN1ZZ*U)zFt})@0v4DKeDH2~BS)5D3 zg>}BHB?1&01+;MQqObGF1WblGADPtDy+R#B~fWhZ53w z^sn!gF1)|mI3toeq`YL1iJ6Q#gN9V;Hh@D~9orv$lZHWt$3k|dQ>pxZFbPOYQWk=y z>E~9_IjC~}y=|7e^<2PspPnBK7D&)&aX&mVvipZ=&6+k1b>0}KKgsJ6avsQ0r=yS8 zeR6(nGt(VyFAGLS87FIx=;|(m8?q5G@;{@}*$JdZ3FdUJgI0fRtH1hV?Ay^AVoTC- z%h;PcCdDM*P|8BVuNXVwULe}S%lNi^IoQ)d zA)+kWjqYci-wI*^Ts`J)fQAiv6gYpF3^32zIzJ<5k$zL<(J{Y3yKM)W*Y3d25~iPo z$NB`Cpn=O8DuAFwEf0;kkpiYDRu-Ywf47=-a&c>*M$t6}4*Pkj1143d35>XBcaj{Z ziNXvj_uFD%?|NcQFZF(6Uh$0J=iJBZ`cope%tPCovIhO{~44H`f5>2|ip}AFfh7CrvIp zyEjZ=rg7Yly`8SR2Tn65Z4Ui_xXHM)eE|{OpAQ!>_IzXe2FoiqM%7v%%@}jp+QRrp zV9SVc7h?eIv1k#oiVitpLw}b70Q(8Wgn$3x?F-2MQW4?zy@~%>U@FKNh5|{`w{w_U z4#-?Y;{_saLWq<-DoT>fgbDYYV+$=OPxg{5KyIYj7h8B~ToR|LMlJy-@1~nPzbrt9 zLbhY=N)IA3C_LGF1kIArvmH!N_o5~~P%4uR%kGh+<3p zhh(}FX4>d~nBkdL5wYELbk;1kD){i>=zwiqz`VolCser$0Tf5Q-`m@Z8H7039ME?W znuR%BZJNa}f>tSb4;s@o&Z6|P0fXY2T8TA8{(Tk3bzgP|CN6!VA;>fciC9#jLBZhL@@|u=C|~5GGd8QO0Me-gLovbRvrk>$8}0zP5CPkBrv-I@e90=` zil0^HWoDaDOs0r`IBe{z7@|sPB^1}Y`x8NY>QG^Bh7L`ECI~RhQ)wwKR{mZGsG_bQ zlV=^9IV5pmRyA6Dd73hEgKMPlL>B=!L8^^2Hpd19^rXoIGaLzXjPXm@g9S&>`M-IX z(3SXVD9tM|QTO|hG0F&k_(S3eB}$l4>-^@MLDG3p?@I{Iu3(R>K;~n1%k~IzaX&)n z)XxS>N`P0y=}LCy3dNqR*o-+5h-&5-Q`1^hyQ7GdB}gsQ6-*6RAOIH9D!&^?u#wE- zxb}b@PKMFmO29uUhK=`U*-pbd)XlT+TOPipIm~s>U!Cvx( zL@s=-Wq%($k|}40kpdZit@|j}jU#chkn+FKefP<7K5hxYwULBTgvC;J>VBwY+`By> z6V{vFY4cQ=jov@4Y`y0)zz@$bg$+V`NkP#Fq*TTgTZ_qk&-o5?Jy)FyrzgyBAg)>5 z`C(-V8s|Wn*8eI=6Qvw1Z(m9*0rz`2s9@hM7VmvPwVV1n^xV+2x*DxD?;|pM=wH%| z+S|W!>g}!1m`wI6a@dF7chWcqVRdod=_V*gH*nS@Y+{YpKC&a_3%s{GSy>ylZM*4YFP{_sU&)Bx4P=tf)Z35ZO%w-kL;_x99;o_d zIV0bt2l018Zs?W~3%_>Cqu2pFT55BEW|xoC3gCWfYlpcm5Tgu9#{8h`u&};2Gc(he zupj5Xh(R1@p}#VeY*YQ>H^YqHeUmo6h9dk#1Y^+LTN)f%2xcJ=XvdaewQE@Bt|zo> z@Yose9zL4bxVp%JI0Rz*=Kib16e_`qC>6Y^Md;I(E#YNt>tlFrgNQ zdw0yalIIs36YJ~mpC+gWF(UV8Yd>?iM>MS7Fan;#4l-W9-atkH6Vg=RnAVTXtg|N~ z;KwCboQNRdDp)~OlaHCAB#J=wqgvYau|;(?-k1Ba3Wtloe>e(KO%9AL>#xzwsIknY zoZsa(0L!9fy~e~kaEFmC@8}&7XjHfPVtgjCPi7!PqL~ zzkhEN7mv%$a%e%q%4hj$nd!7~+!wJqMK&s{D|o8IiMo32{`Y(*y!-nv_v5kD>uP4_ zV%d{!!a)TZhqa_IE8eSzu4*H`OeAQFxSwryLVuVG3eOZNjUHH__dg>TEv@q%`a2$p ziD_X!0sbq;pMt<9W*5(r!FFKw4fD)?ADOQAS^d!l&h*g2b9eS*5+I!lR7)m3Dc}Or z|Iioow5*3D2qO%>JP`9gH|A|U(S>Hut3&dWCl_)jhqF1)HS@?rs2EI8sD(?{FB|SH zes|Q-H2$q+YjFv}+=W#&a+4;8#;o_@ZytdOZ&P36_$EsySnb4~LE+Lqrk$qd?BWUs z{C0MTNfa*CrQ?rTAtXVD)D?;XS1UbKHCf*h6_A~NA{CXJf=tx>(lN#{-@;oDT0ZCK zI+#`O^b)$@UkK>3hRvhz+RU(<*RQpZsgOO-L60qOfc!Dw&l}j%-l+Q?Bg5&+Pe%A- zQm^ooQG)<^(h&LUZD%%teZ@l6qg(S1iC`f$8Ef3nj-u= z%ElKgp<@7VN@E;+u=g7Et$b%vO2<7n;hx_3^BhNSlTSHo*0DkQGw>#d2f_TEK8ljs z@kuKr#Z0Jmw+2VHbEM%GmF1zx$aXvbkr^;$?AP}Xo52!T`0zyd|9$WNcg~8Foo=9> zR|lQ+ApA@jrE}9R=DL**J~^aMpT?B@)(Q7-Qm6L878giMOxmaJ-=&)785=*6K!yf7 z+}^C;-tp$S42!ENNL-FjrX939hm*N4MKv~g9|uo~c{Xi!TF#*SKU@GeS!H9(s8ULc z#Q9xRy=#*u-R_>9^tDl@GAi!UBekh}n%<7xJ77`v6#r&uQP?9wjb>6K`kray>f%K# zRU4T?(2M_FuF%4eK>G<9pM!($hB%}LffcDMs1$d71Th%p?*6-fM(ji6zK>2W*@hYF z5uGzdH(sqo5TZ_>FcNhl6>Z#~QLypX{fWoKs8IIWq_fVEK`rX;l(&;SDk}ymlAk`E z^)?u|Q?aJV(2@VYtbdp6v{n0Zn>G+dWE}@`Bxs1tK(T@J)6-5YI ziV<6NBTPa-BR=s7C|$o5_3ubHl70~2nvE&GC!BakJ1IR34pAoxM-Xfc~PhWsO}f7$M5W0Tk6p-_dYNQ6 z?)7F(_hg`!JBf>?1QvSCf>R=OGz&0SFl|R4=&0XRuiDBpZIRUWmM8|0F7ElHP>K~P zL1c?K2{xq^l!>W`Z|Gkubw z@A}-LWy@-(hxLzS!C>DRkxY=7A&Wl7$Y?{T@z{wIEp`8O;AKb|1%s20lgrgv$Q58V zSD1~09`0JmzQVM8m7QHUbe;Z2=CzZVqIo%bBr13L=wF;wt@DREza2N zK>1Togn1|vZ->4f76oR+7bs^G-MCe&NSy^zYwDQtyziWKaip>j1y&TkjyT1Lee z{4uXJP~oP%dmlPo=&d|)p_@YF#N7&l-<0BrnwP$KQ&N)4(FzC8pZy(!SABURmX*RQ z(szzZ?-%3Mp|->#!SfjA2!ek%U~~qjd{N-01O{Ug=TWg;bdu7%Go8j1@9 zaC^$Mj7^VwHw7cE8i-I&yUdz`Jt6nL`^BbBn=UUcn)?3nsYdu)a9NC`OAjB{N}3NS zmY8Q7<8iD}{-kOi7MvTXr?*Zx2&{kM=#3I2Xu9Ji4W0}pi;<6Prc)Au=m@_ecviuW zFyPaM?mymkm2ojnAwfGvI*1`W4_ulUf~v6UI5DzJ4K;`?6`S*j>D&FjR7nCx z6Duy!E8NuXicMsQC(zNQ)W^A(#le zO(^KJSt3W4vhL$YA-;;!Jv|aF;=Sc7l?T@~OL+zB>%wK^;{jmH$z@8eVm45|;Q;R) z9{$SiAR^%HRLCtD1WsGvW@FjmM#FiZAS$O+I@%!FGx1% zzv#vF%dA2-A;;d#I`a^0W@U>RMHl0ml0Ue8$oW#IPMX`nPZ9Z#>rkB>aHTrp_!mcmrC5 zJg)O)PuG>d+&O7LyUoE_5Ek$Z879;Wv7jOx3w=iP&demdMt90~Hg>HB)k6fxY)VY7 zsNB<*4F)7DS=&a+l)NuRr;JIKTdSUBz`}dIf{2C+1z}Y9se}%+h*cPwT1ajWA26E` zTGL7Ezac>DgR{HIihm~(W@fp6ws9rEy&etm^awHsNDHCv2x4*{g*Y=)#p5}H#yPG zVAFVV#olAP&ViQ0N?&vJuFtGK1S#QcfXB*S1JKBPUWO^-3fY8+_Q$viIU2of(Y>zM zH!sLlc+wUKI~_eDX7Zv%I>xSVld)sdo81foKE4VTM2BNByF3!wt}G(!Kmji`HRElQ zFLw&4P(;7LNK5=8&aN)r0o}>w;`-LhE`ILG8AP3K*T7uH!gAMj6``6e1{$41~ z_*9yBj~}VxCm!}mJOU6g-*0>up^8v7lcgaeL=Nzl3V@zwl1)t)7-QSp3~WgJa>%Ic zBtFK>9%S?4puvL|4X9`Ml(7p;(+$L;Ly&EG(w9N_WXiQjUt`f|en9jMvhrO(uAx8Q z_vZ(nbH_J!s2#KexRgKE#*mtzt-ywnMw6J_YtQ{haj$9hmFzycccQ_+se6W3h`&8L z^Hs%9{Wuwpd;n|on?x)hFu@SeH4#%1^~x+vuio{5C*v2Ixb{QReX)_?eCz!7Q2vd^ zUprY(l~8qrGK^MB;4(fc1IihNW6U_m{!a!BqF|$|Va?+f>x5yq`JSIJ&#^_eAacn8 zyS>}@<_HNb6M~X3>txp$X985lZx@A-uv-M>V%MXLE>75Qi?CBwKrQbaIq~}WUOi^$ zuvlfN%Qu}?`1;Bu>uRMC=jKp_q6=`iSuu#JK*qyzW!RBnquu(=4N#ULFhCE<(mICJ zLLqB6rhDv+Qw=%n{D&%J()tS>YgDhU(=W=&;}9VzpK)4wd4Ye)?9rt5jeg32|X@ZVs!-yY!?e3Mp6%ph=G$JoZYq;i0&e5ti)s`O9|DJN)kQr_y) z;7G9nI`AH2srz-kJV~x;yY)y5k^@b4OdraE8ZpO$=eyx&@PNs9hhBz$D842lDxe(b zO?GUwU*AR6G?IsoRn6hdwGS&}(bOIrTv^uMqPmfpt|K!y(2j4{?ag4;Nmhk*lM{5N zSC#6CU%VNoyYS0tkzL0j)*)L6sTq|iK_zJ1wry+`Suf{0B{d~XRN{Sa zs4up=Gra9HcJBBvln}u46jp5NwWPq^yJZiB95+DSn>E|*3x0~j`6oW8+u0DFCA;tow_!4zdP+9!%3;V!^4`%$50(1DvF=seXL+msv8xX76R zYgzX`2|6xK%SKjKq23F7P*_(%MDdYE66LS3!S2Ut@?V38IJ)_@8`2WHRkQccRI~z% zksNCJ(UdV}di(e9|7Yh;b%hWmUzCEwL1R9hJM?co;fAqG20BvdCim;&KMDbf(8?I` zl2KYj>FO-m+5e)^GbrccZb?Z?p-Q={pwJ=8i9A#yWs!7oVOPD?dQ)ACG|t% zyhb-5s&s1HW-yQ5JUKTIJn!pxt4YBIbujj(B(BX|dGv${DcA)ahjQ9u*7?)!9*W9m z~V=f;^uFdb$|dvYLCfrpR}Y0E2bQ-WL@oHF)iNLiij|Zt6QP;wK|^Z;*y|d~erdJ9h{m1eH%9 zT2iC{Z2Z<0Ab0cxb4aRu#mQ$^!KeF+mCJl?IoC2d&di)tatj{82(18FvP(FxO&}3B zJLyvP?%i8@`^R|>rhIBv&HO*lV_I%b4{u;EnUFBgf+`g_|DK|(vU7#`xDYfF4QUr( z#r$o&STP*anAe#H{rP)z-L@P~?aEAoMrsqOB_hlKP+ODO(+A&MaNV?| z*{sIDkft-|$KF%i5ZVPaCJ>swxK9f82WOap*Z;Hdfb`bjqQS9?GE3uN zYW3~gggdf{SAl%3dFPtTJ!bEteZKx`CB=}=w@cCAWrC#0=d4UJTuPpnII?>6Y6Se< zf=h{M)fB|~qEdH<6R2%o&*y8jO7xsZNRX*)!{d&Z`rQDfPsqZoc+;4R$aWkhs%@}i?to+)&Gp93ElR`RIU z!9}1B(H7PVy8V0b;Ow~ABmeH*8(nfmnTkdFrt8>#KMRqahPlqPp8%a5Mt)HbN0AZ{ z&d6bBjryU8dx2%y6{ac!F6Ma!PozKk=fDAWEDiG8Ud%!whJ4}oDJM1qOr6S2qLdN! ziek8m5-3F>bdcZW1&vZ%M8Qc11wq)+uz+7Wf+$BXQDN~N{FVRp&qf=0XcrE(H*kx- z=&&`X)))1%1=pDnfM|}6-yi+@5t`Q=*NLEX!WB|fo*G~D{K8ydqb8b~m3e#L#k{`c zODj~xMl~-0n)k!QfNr)$<;rJ#5o`O50#&j?t=xX?*j>6@o9EQhX`X88eGuIx`I{a= zR^dzk)9rwM&Ob5&!>>vhsvJqtWK)QEo8G=C!(dU8h}3Suf&%8@nnkLqdz0>mpCfyWO2v@4i(QjGF&;eU+~Wg4^$pPB9tU8 z4h{rGVa3X(C=v+li81kQkGy^))d-V&vB|*Jrw?J1Iz~4=h=#E(*Gujx@*&_lFKjyS zERMb%ZrT@S?e8MF0h{!+HJQc$sTExR6{=}!QjRRP78ut#=0QL9=Bbd)@Bu~@4wuIi8taip$?K&A=rNSA?wfm133rMblN5!Bb*(;oPk)uDOW{Rs|8_kI-eGljSG zqD*i0LCBEWv*QB5>oVNBLZ#eh@pxqsnB7pzD5~&vQw>=u zPq0!b#2Ox_74{FZ{kSm!QC8F{6mrK=>A+?Uajt~2Bgt3>@>KK=85*dwL}E*FhSA{A zZkt6ML?|AuI5xmdPrk5e^efrZgQH*vcmVKTvz^;2KY)XAqC;y7z+QST*8UQ`YNF@{ zxK&ZIr`~TGMKY2_YH%(lJ5Iz71%v^S^ubYnyD6mUQ6XKI>89)X8Tch~L745}yK zC!L7_=6k>@<}%<$?$I5K@*Mq^(FdvO#Ay)KNeDxH%AR}9osvkjlYUvBSs5N-=Mc^X zK3|$ULku6-?6e({lUbFZCn~`8Y{6^|UqsL{i{=g|S01P?bcDlWnkmXAZBIwN3#Qvn9?#YlNMFb+ z=zg@I`(sZ0N8#i5pXKe?fYF^43Q$RqaxqeiS6d8J0a8Vsvg@NE6MANh0&6F|n!(41 zMTDcTNs^yY5ld%%Ab!ZYhs%Hqb6ImPqDO|HusM^(&6BvxaiuKz0DWg@QXKqjL?ECjkIoAq?3d!NVCTNcu?QXQH| z?K*X+6pW}QB`cwbz#cLePd35O1T{0N+)Xq`(9)d>Cnn8vExu4Dg*bKbkyqcp&O?eJ0!DJ5kfHc07?Ifl_{q*G z`RQ+sGD$A-0C)GAxfR-ou(hS5#BHeW`ts$XxD%CpaIj@XV3@uLCzwzUtN7XsT9I(y zB+c_)@au|>C{Q*wS@nj;3?0nCbwsZ{>I%XwOR9@(YL+6^?C$OX(-u9-5qqcS|NPUq zt>KT#2j{*V*NI7W%P%`#JS1KBMD5xyE=Kx#MTPs$2o1E_J?^{p(!GyDm+ii2wag(R zuI2n*dnX@@j@}!(CF;yIEicdH4nL1Kc-QCFm!DTPzxbKlw9lXW^|wu{Jq4d`4K52= zGczx^aDRo2+^FaihYo#mV8o%}@RcU+AGCq%$cC-IV`>91M+vIR6WrhNq-ZI8&*VxWd@!$qpzn#8C zjNQ%%AXAwo!1cSrMPuPC}NS^Wzs!*#SzuUW*R*Pemte^S# zewwrZfn&paIcoTS`0ZrnL?DC{>1deA4GzG8l9s~3ZSh&rV#uyM!q#@uk`a_)nkE6p z`mTIA8s^=Wb|n|tVQl;T^D9BBvhUu#*EyNOrVqgi$ZakV`kJEXNa1iG+uPdiyDx>j zKP6nLNe&B7HyLZ0$K`79r2q(Sd#T6|)*Jb>erYZPck6*Big%}H7kfX#2e&EbKE#K7 zu=yN^mNb+8Lx0p3K!k^ysQ+zeEM8t5|0!|7W3Z?~?i0NBb!&m!098DC>_|n`kSZbv zFs2MZB0FTFkutuOgONj{J`FUmI3TW z8;fT-LM?k*Z=~F@JY}sSyadCb zMSm{@X{g&rcl_+cGCttRQ5F`>8S3C+T8r}`t9Yb{z&fou1Bdv5E8bcB;R4wG-G)g5 zu*UQY-A;};luXkpHs?Tb`J#!T9a7*G*MKlP3h|wAuAPf=>M*tf0c`rEXQDM#9#d;3 zTd6em8z|gl(TWsFhbBjh*)@1^K?+N767QVb3g4al_YT!`L1GL z!NDbCYoR@G&#Hm{Hm=$fa1E*J?)f=OSfpBoU>uhj0h+rscA!iw)yx) znx{Wn=E~GHX0SLpeEs;O4W(sn(dkKor$`=!z6W(#csp|22qz2OO79jNCc_u`ZE3@H zunz1G9W%HI%nMXcVN5pMW>W1CZ|l;{BeQ4-?2W={6ADzuMfly;rXI9B70QgcCLIz} zKoh!u9hmM0s!|GSdmsP?$=St^@ z*hMy0+Iw!oYpKN$^!mILU1H`7GDz31embFAAtMg!3sV;n{6ywYQYatxxvU$U0M_!f z69|_s&H2q8HB!SGP|B<`P7C4--u8eBSz0&X5)2^|*k9CafVDm}F7iRCr>{!HU=qq6 zq5*6DUz3H>b-@w% z1d=&1S@0s$VvOFJ>?z#|{NI7`1%}@=re!!6KdlJ9Ps~8ha|n(Kh&{xzqQD-0qsEfx z0SXvvGWe#6IAoz~&PHBvl`aKf&3}Ktfct0t`oD`0wgP6Qh^?lmB3=+W#KRFy2h0p= zuxSfcFJEr9$8^b~#OEfLlmnWt##uK`)I9y=Dt3$!t|H!Uf`asHtS=n=;ln*$zdSch zqO2DBHNo1tb@2*k(X2wEBCL*>IkTOVAgpL*G(0SKU-frd@Khjs#7vr~(gud+jx0}Mja8V1E?{%BiQ^7bLdg^t>m z*f024v+8P~cvqm|361qKPKx644qm(JzM+K*9oq8d_gfn%r@Db-FI-+;5UhvCgBRz5 znO_MdeJH7dvD;VeOliI7Q(rKx_C9dniMD^_O_W(emRye%MAR0v9wqe1+LR1}8mlS- zEiKm`Z{}eG;g!0`%wy=upKt`V*OHI#f~;+(kXx>)UmF+s_zt^j&YT3Ocu7AA0~3Q8!MRrsmGKxn9^Yyyj+q&VCeTiBUqQR?;IY?j*4UpXc4#)qGNLUH0`p|~v&JjLlI?aVf*rB%K&f!=t%m~K&1_lPg_~$B!c*K9eGo*}JTs>Iu zMF9z?=Hpc?MY!y+g>)>^|8jadY0LiacLz8hiCvTzS5pC_OR^V1F%K=5;tn5uF-AL7 zK9O<0f~gvT8D1fNM! zSTXPyWdhZUrDaRP4F?-8lB5iSY#ZRiksQlUSm`))b9*NoIZmQ2qkF!+Ky#Fkk%2oC z{+#Hnx8tqC%ygKipzFsT0=k2%6TG9vUGd3%y`s2|RgXBSq5hOyoxriBJUg{MJ^y7a{W40P!2Oua)liNJtOaqkS^#GiphrJkCJnio3BlGzS_0JtK zIb+Z-b1Y8IT*IZT?Gs`mg^Z;s; zxV*s!KIRnT0P55SG+30VG|W|8jcZj7FviA>#&o@@!4wPk!YlNud@hA2SSv&h26W{c z(q^GlVkRRFK}TOLS?bk6oKa-iuoRffo((0eZ~MOw6>ys=z|^TV3@;2>!39|UcUVJ zgMc@6FwgZP8Y3?~1fD~P;cfyPJFJ|!WJyn|kRXEvgpqpnwspyD&A69xsp5hox))OT zvHGgq`J>)}ZjR0C`kak5*9|-lr4oh`2O{gD+d4|C=NsJLOwnmBV?P1cX3Ti}dTYgK z*3y-*eP#|dvCJq%RYW@G9XgMPYbo^2^XCmfE(8sO=?RgzUJT1xRY0=g1iV8_6*D}H`kBCH`K zmT0X(tBT(7ujr+Vo4Op^+qWmq41&><%<2I0n2=!sfqAh~syaHp>(ct;$*r%K#w;Nl zhtPN{E2XiV0Wt9GwI^m=D3~X0Rv2EmJOIwrgt6gg&+3=1AxR^0*?`#|(H70ZcF?!W zh?yX_k>-|`o*Jlvjh;wb%-tlIjyUAW098Ds%ygK4%T7;&J8LAhGFxEu`ETv4E_ikov(z6cMuC=KgrD0w5Hrg#oXTQ=nqUlg%}9UF0ypLKb>VY zbXiwOxu4=ZD(X>SF|`hO5Fb^8H}qWkKZ&hku>qC~xWbcFfOl30wTFR*zsB^LBls_; z9zFh^c!Q83zFeiH7YZ?+)+-7$@e8-)0I>cET1*{M0!1Vofe^3*VTQpWxRbD8lHXJn zE^BOiXYUC@a+D@i39Kbr&;h$S=6L7TOv2Ja$oCXTOLjyxdWC0^EO&Xia~iFH$Mz;{Qwc{h`kxD%P!XO^2{9iv%bLBqSs?)Krl0TKRstWWBuh& z-~QX6Xq}ik~Hip>B*HCBPv??!c2gCxD6Yzl_y!_4~v0?p9t6nxTLr1sQ zh-m`PSu8fdDS%py_}nbO>^<34dJ`?z$)l?qHNMtx#V}!@VXK zE#GVy1S`3b%mQ(?4k@|xvTQPOSf(|24~DkVBi{rT8uviR>*5J9Z)^S32S(L%pUWPWT$5L0o`_G3ok;1%StH5s5&-6g0wUK($NkdilOXs#u1={HrW8El zc_`i~xLV-1%Li;flcrwuKTNy|_{%oa?+HXD#_3qaviu?ZL6f&l7!J;bGWp+7H+^8l zs>MWtIh1F5{8q;|MeGX@N%bJv{MyCkT%=L_7`)c$2+(*j4ZZ0j?#p(<_Va7*hZ*ZbTSipZ4$yFimFY z>%Q}7OhgOBiTG!1ILcv(j`0}VIlq6<1bRlYOw?>?|;n z%yOuX-Y-0?O#~Cm5=k70gMmv&agT5TW$8}GRR(guwH$n$Ljj~l-JPCG2P^OhBAl6L zoxeX85}~xjGIB&RK0~XQLMnCHR3t1Q>@7F{y!+-qY926tgqGEK^ul<4>iVwd@4?w4 z@oT#(n-J+QI*;2er>J(_x>xvgDLYJ*ul?xuiM#YXX3+>o*5WkUu$0cLLx(--I1;lu;GOYyZ)0INs_`YL zd@mGRIOa?q41+d)-i@YA(L_KE#xOvb1@rf*Fb`+{iHWuSa9$|%i2T4E-M_!SqH;~s z972#^ety1350}J4xYaPtdw?Au(cPc7neec%(+4phL3ZRd)a^&UILSRe755;(854}^ zj8aFB-txfwx8=CP#rKc3lN>2q1;o4!x(zVXjCo5{&;LpNYYmqVV@m$$8>r{;`|?BJ8o6d`9Mh?&fU7nk zTO8ncQ6%d4#vs3u#I{XC2>V0X&)K-LqSzxI)25bsIiV5-WR09mC3p%cRnACSclVx% zz)aYSFGQ6<#r6A}i+BdiTJzjz{*&h4_*QUgAuqhy!1UqtxpM;_+vFHf@X2D;ISjd_ zJLR`cilR&tOP;I3a^d=HX@_`@KgNfN{!5k|bqxoHSLca^SmUV<=8vSaDIwQRn)-5c75h}{`fxI{rjkj z^WNSgciyKCe-3TH6Ka1I9gk_Z01&LdTexxwK#VZ_xQti9%0W6M0aD0)OSaOS_mpm5 zW?Bpb!3WcTthl&Nneq1hS_2}~B54R06)==kD9i#H7a(L=O#ehKIU51uw`nvKmbv%xd2?CLh958o2ZEAqxq<Hol znF2>%#jRLD}U) z)~W}^hLXHFLz7N4W!Apvj{v#KfPQVz+-lf6zI*^>^M)r!)q{h$To(7}NP`AW{s>Zc?b2An1^TAf_H z7woTtqA?NB2W@y=#YUo0Ug-~Da3Lk3l%J6B(kjUzkn6heWO9%!|KsB@7@KhH=FOYU_?|wL#|CDpKM$-%EzCOtCR)7m z2@jzL`P8rJJk;0x1ZP9Tu94=@^JA=T6w?hOUU3E z*3_#TNrYR2R5Yw>Va-k%Rjkd_@ENf|e4d5_bA5DmW46`2ZVh(6jXL@olS(T0l&Y;s z$hyYI6im5^!{mtJ!-pq)bUZwPSBY4!hgfvN)+_Bf8d(Da8q3+Iu#LvaV=mTg6J`~| z#z0a8PqZ~%tM$P$P+>I%#OT-??`GQA(0Rr5{Rkro-HpliJLP!{KJKln?Z;q^ZXo+~ z1esEnDNml9J=2MA{PS4mu!XmG=Mu)qWLw*Lt8RZN0|Qph2?{i4&hkt{TN#ZIB3g2* z(FvOAh%q9H9W^PJz?Y9D#g8$7l?V9Id`PO>PhmAcA)wmqfO4CLK?p@>zbZbizeEqq zfaCI`M`v%e??o!Xn_NvncQWPOm-JUFIly_P>k?q7O>lqq-`#81UTRj>M=&eOgbrkQ z47-cUPOuV0!2*xcnX?yQF;J4{{kpj~6FN@#gTBfyFuIezIe=e!mrK37bvv`bd?z~+ z#Z?nCBkO&as9ObeqHdN&WHQfMvbgCqCRXS>x;xYakI`vf*RK%!^#Q>(+FY3LkcQxJ3`>0SO7?M*q(J->sSDT zA&?6588d$Rr(BCN5Br33q-BpMjoh&)udO=MK-)_bfsyI1@WKN$eDPPP!3sNcS;L$?JJ2F)5Et#X}o#-mTQ8}=SwwD~N{8fwENN^Pj1fp5xHk^8~A^>BO#T0^E67`t&MGb9ttRyk27GG+{ zzhlECOo%y*xsxgwtfA5To=(E ze%BA3hZxmDdu-ZM41J)J#=BRz3TTZY3hXA=a9P@3_P2{07HdAC9j~V);uhjtWY|qi5k@#Z7&pkOT^2d8aqY4g(NnsK@SKi>J1kR7S%b^?juBx#@L>5f{-WW<&*wUw zJPZkKgc9!^k<(ULymiv*yGqa9j9}QDbxze4MgBZ72OC*2tLDk79$(Yo1WdTm37i6~ z=mg7!=}3<2QL6+K%yNX`+A;kXGsP>o8FazhsUFkED{y5ua{22})|pkh&Bkj4>ZWXU zo=Z6}f_AG0W4Ft|R8nev;#4}e?bv(gjg3&mWQy)ZCgoM?kUk7^%F?`V?fds%EgF@2 zTy8Ir_&Y?9=ja7m!rjR!7GvC^ciXmY^PxwYfxxyo<#G*3an!OSDB7pahLX_<8PiA^ zDDeODp*E^Zlh;BZ<~3ZPOoKUqmQwGi_wF6HxzPmu6np@?PTW5n z4;5+v=ldCMzCq%4Pcc}7Ox+L?bAFfCs%~(I{e-a8DRcH8IIz#=3sXLrX@!Rds_mxd z8??LwK?pDlrNg&R8^&~X0e3@tX$lA+NA2 zxQ}r(ZB146k>zk^L#cs!psT>06DFQ8hwp)on_e@dms5M$T}pXh4cHh})Y!1vpSY)njQBFGe$ z8oUef77{)t1w#p4$G7(#Mh*&tqoNNS*ui1iLJC6s~~%&ENdYB}(Nx zY&q=qjT>sq7c_IEx)uaPEM~rZ5p;_w?Fx!J3f{Tc7=Z&_(LP{cGD&Qm#H?FH1>*7~ z6k+o2|DIy(D4Cm=K#PV`!jpy&F@A_7uCq@2Alt zI4%CzTP>*%?*v8%!Bo$xTQl}Xfio%urpIOt-2wYLJ*m5J-;Q0b zlPXd}jJ(AL(y!?&b0U$=xm67WGKB-k&6JU;K)rdVSBUn8VnXberOJXm&d*zC4DT63 zW|(>H*O^_62+ZTMSFT!R*{ZKcFZ=ed7JkE^OVBKkgIdhy#L`ZVnQY$G?2W%7WDvod zfHOGSQsY$VX17$4I-R%V-VCBRm%(u*<&Stc(*TNBxgbX1-HC(m4V$dfy!^wdXUA!0 z#WspOB&{ehQW}7dtqy6ksP10(sNXi%sW_$ERDd{Q~ zQ^t9~t>SMV@%5PJ8s%?*QQOw)pPLb%WK|q+jD*0Uu?MrZ;vk zqd$y()usG=jxD2kI<`AkWuCHnxd#bG^s{1jAte(X2#-bRv;fes9+mjjf6khqBFo{= zDRd^ONw zG!l9-*h@TR6*I0a?cT+sV3pC3-(=Zk&elmHhxfB#aXS{RCor!g7W@8cm>3CjLM-@r z>H@4|h@&ZjXB_qUq0JyLVNAsHhD8VB`j`f~CBQoJe)`LX#7!|P-Lr(NZ9?gOZHEfB z_K)7I%ZMu(MRN)EdScDXU__mH!anWU2{37J9k|A@UaU2x(qw+oYRK-}Or4gjyg9j` z06Y~wfcQ&hWK0O#1y|%|vvUW>0al96ijpj!AC||!DSrOu%@*(}@lE6PcGq_)y0$Yt z$clu3lN1Q=qNDtyBzFgcgZtWCScya?OwF>z^exhg?c*V2@4*xZ>E$Ndf_Y zQ6z&ALlH6Ie#tH-Uh(Fb_o@zSKqHG>CLuD?0Q{0w=KYsp^p;NWBKHaNryS6L*Z*bi^#X@UuF@$gU< zYf<;k6rboqrsceBV$>p@S1glxeY;DLjId}7*Pvw(bRXHsmUd$pVAojs^nA4Wb=dVG zM33Yr({9M3E)tUz+27k4JQP1dNSGXRm)2S3j&>c@@&>2pfjU*u9T|p#G=Xy}NJHWQ z#AF)9>(P@B%ypW>LV-!W0ds}%T}E=e0Ox2ww+UMmhk0@twT0QG+YC&{Y$z?9t$C{A zALWC8Q{p^Zss58SE=;`PLcjMtZ73^|XtD=U42aI~OfR}c_rS&WR3nbA}ClpxvWfiJR{B=R)bRk*DrYl)y&WzxBe*T@w4~8N%H)iTyhH9`>xfypB zpYo(2VAk%qs~=aCkXUQ^f>B-wgH5^>6c;yga{4m=#vjwQp6`O~{YD%DTT;k?5*La@ z=VO-Pz%!I>!mt<$bHucLcWv#0W8LlPC)DyD=9k5t>H)odrIUr~LxpxtHoS>UI9F8H z*a~krcW&LdLI)RNXNWEkUxHM(Ck=PQn~XoR%x;XjLbwP{PIqNV;a%yHIw-Z^ZVcg9}$oEJcC-j!e4`E~MSF=LEa(@heyMqqb99clszgDb(`KG5ZXtu2Q|o)Zy8)+1qW7W}mRXDLNXc7E-cuec=6fz6%$Q*{^J4 zM1c2+07*SbBs88lK^c6FjnBU1w}B#T6+jtl*($Kb)4@z>Ufr}cqmm+dI(-}51Cmy;AGJH*y-`rk`L_s=l3sieL+0uwo4|J&s;hpDOVxq&vJd+ zdDrgUvT%fg%Zphkg>4CTxg&e+anxI>!C(W-E|^{UqZKA=)fHeKf_71nh(tri zMKr=f#gbLY=n7@a1djeR)RzU#N6J9C^#Xg=ILj{si=JH?CXILxyJmklma(xn($kST zlg}J?*J;&bx&mp1dBpx9s~ci~mMbE^DbI-sn3`nbm=&p0*3LWUqp7vD!K;h z>V7Fh6`ptxLMO&vb>_j4E)^FriMCC=&`R*=|Ib z=d${&nu067Z%H=i_zKQDXr`oP9$NX!No>G*{fkcyP8!u^r+_Q(WmF=6zW$f3BjybhZwm`(Xba@y0l@$?D+>CpuQtPgJp8s zE~XY1ym-Mmmby`~`rDng$g)16%wfZOKFtF27$}{W8ND_Jbznw9?<$mU91|X%u(!_W zQCnhEqI>M%sxxA)?c1UD6$HBsR)q(GxOoJW8t&<28X3l{oB%Zl{L)RSY!9jB1cTE1 z+n`I;MR#pX%%E!!dW&ES*s2jT0y(rIOOPi^_^BysZYDNpEv0Jv>n}M|(wLT&O{**- zD3T!K3#yK8K*Q6HP^94nh@~{jMr-{kF}py6_-M?|Yw|pneIES3Ht;z$sO$xznWQAa zX_M@3&qQIIo!&&o7QBLMYsRTwrg2W)Cke68PU{1}Y@~ih2pAjgl%yYb{&QVnG!R|b zqFR1&_B8yJ%wNbj7RrfPv<2*%jpxptGx2Rk*FlT>cfpW9fiCw=Fibv!vOFg~MKZPO zZ{xV%!a@Ma6L1}-hgEmGTqS-mA?zCLzM62y6u+K1>>svg5Y{(5gu+=Y5LN#1kG|B? zk>RIM9YC3zK=yLHVRIC(Tv+SK>(!$QU}_jFcB!-h{Zt9EAjeYxK>5)1@T z!{OWdKVNzM?~}1=o&up%v6}l}ytq64o-UJq(cv+NqD~HabE-3g0WqBCGh+9k9K~75 zuk1=A4IaHYI5>682jfPu=(Ug!ASd-g^FZwYPs7aITurGzV?%P0rKHQ9 zopU}9QSGYBo>?|ES02IMeo8SJOp88iKIQMe-bDjbVkQ@I)YufGje|nUj<0v5JQ%wl zsiSnmkQEegIAYCTa5XO9y_+y<=})Z^R+8)=w4$0kP#hp-lMS7kD0pZ*iyC2q1jZXP z?WV8`8I=k`a`I%&<&kfwGC5*ch)#*S0;l{651SrX?u)R&NG1ve@?qg%L0>mQ)k_C| z?bk{rD&NGn=wiA?{_UfUkc3=jpd_)E=RIKc-~8ITVmeSxyH-M{@33U#^V|sD9)z~A z>zEUp!uwIk)?gqBjZqW1*Vt)x`8*`V6seUM)$uZ9Yo53a!s|x6a`d+t|AC?e>1{@u ziyU-$$%|29EGXu0)W|$_6dN+1w`B}=-bbbM3)U%{nX6dso;(9G^2PEO^`t71;Ux;2 z2m8Ov=%uCX!J}Q4C8k&ev>5WQ&c~A)T~+I}2yBYw#rFnLjA=ziUUDLA3ONaNzX|xH zG!Zg;K-3G{r*TEjK+q~0VfpCF-7vPcGR`OL3h9cFmbXro8QQO-HyZHhgnd1kVAFER zFXdTe1RNbzftv6?s7^4YM1MlPvbA0GJsv58gDjmDRgp%F#UO9y>a3t~9o4&9umylf zt%hxrN#UaB;OvOWi4<}aNGUtYPElWe5+nq4Vi4^-Yp484vH8N(xp3h^6(eR#P|C_OHF?jdRvAuNlj?#hNE~6Vtw1U9M@F$IMLST>57n1)Aqtaak&htu69J^<+Q-`v3Wzp` zC@+g~Y+>#p{5amCn7NH(~z|wl4_w}Btun@LdN%E zjU z!XH59Z07XKMR*z1k#rOSYw^D}1LXe0-2Zwf(K>ek1czjtre%m!z~?6qiG>;ayLZ5$ zO1gfuC(J!28&?2$#21gM*cJ~kZl`iQj&cY9@90CPf4(8vpx>cD9T|50#`Wups%RZ~ zFq#82^r#gasG4RwPqTY zwFSm4!3}0;-YMd5~zu0lb~pha=qHHhAdLci7bc6pC6 ze=Ny!$`mEE@EXfXzE@H`|M={n%Jv1| zGwIQR_DRE}8W>l=g&5d0qBDEL)(pW^FyrFN(w}wc*YER&9gRGQCo;Ab-Y9>=!qnAc zkD3=a?7wvE8kt_EMT+Ey53NY^pFcNs)4R>6N4&XSoGA08BwdUMg&IyWz_iicLDIr=eT9l)~E!aY4_$mIfk7<$Kj5E>LTM{*yi*rkgxRev8WA+E z-Khany7x~?Nk5Tz&~kq8t(`M=r=7^_w`XjI@!iQyrc4>o%B;Cr^Xd=F>@Qv#cKSbU zqosYedzZaC`&$3gt09?R_Qsd!=MBxQ_>as@Q@`n3VXNM=4%5|f9I+sNwoYS)dGlb8 z-)m*BFMeNRNu^8DT9uCGUk=o|4PYa6Kv)(Q;9h(7ObgVS$fE@sh$;C6ZABEeROUSR z$S+sS+=NU5duk+u6gW{itJ`+m*my+kjvG&Fd+X$)Y4$-{3DV8Fy)MIs9Rw>gCt? zfTmJN7*D^HYxr$~#c>=CqikoPP;lsecFky9XPsc~>5kgZV1q!s;d9Njdq=M=dV2o* z%(xwEVRZ;HOdvWE_#)GL9u!LfGj)o!EwcVP8$n&hvKVYyg)4t^Y$w%cx~85PvQ>tf zN!Al6E`ZMhgD&;5PTWHAPg-3+JElSNQR1*HYRcHzmx3|6%XvMnaU+n$V^h1mprrA| zX+BJ+E;D(USC+ajke6n&ESiEKv4HVQHV#7G`YG({+Cx9^qPRGd$5dQ2nEB%?CJRZH zv1-DVg^^(gH=HTPh1}E@^0atlGy7z%_B>~vb$zON^8p$S6hLC=5f&DICliZx-~%X% z)QlJ628&xBH8m2}PLfEOY#%$&szZARklB0fCmlR+U;>z9^x?$E&#r{O@z-Ulf#NO0lz4XQrdiXkzb&#Lpc9hdmUD|5b* zrp#Wq#}$x1raSNqxItBbEEcAq?hjlA#)HMk*Xp`$3P%uHi%LoaMxuuOZ5A(@V&~z~ zItwaBHc=fk3n^Um^aK+xtsh@{Q~murlIlG0w%VelQjnUGVxF*wBS*^-#}ib|gaDi_ z6A0)SF7E6$!Ety%bFDavLZ$_#7oRX{C2$F|;3g3;B8eZqAbvcV=kM=dUiFR9dxzL4 z(?|^+d(fFo&PCjb6EHjbVF&TEyJYF+p3{!F4!;RT_Hvn;;zou4&W-x&k0T!lqS?`? z97o+TV|WMFF&R)B9VpDMKsXTkzfI{iyW!$k23nyz+8{PJjPV&p)ugN!ksaQC7H%8r zUb>__r)4$#a${vr_Dq`Xt3snH_m!+7BgDIQ?z{{xCw`}sPfsFe*f=_-flVzRyz%?} zZmyf{duf5kzi&shh5wHI@Q8@43GBuVXJR+J;sHZ>eX-%@ko(gh;SX+IG{Eyr8$!`< zXqk;N$2(?PEjq79a{y|RD(rzn-5u zd(k38;#B;{rclH2mN#%Ua9Z#U(AI;rJ`g(wk?frhoZm%_^-?|Mm7`%QSC5|ycBMql zF+IyQnap6(GVRlhT`?hc>qQ5}F*j~i&p3Jjrn9Z*qwyp!Lo;8=L#^=cy>_5Jd^Ye=QW3yHT=Wf z*-XUemVVMTO}&17Gjun_@G{LL25#sE&5q8SJ2yA2dJUpFA1D&K;hfbQ81pK3JXqzo zf4>163zupCdUfkZD?1UD<7c8TcRKBXIP!3Q6{Z)Pxg6kgM=N{7Udrxg1Rh?b&wn`1 zmVsk7StXo3Tl@K|->BLC;!SHx!_SMlM*7jxIa)$)iP4(?4%B_oZ?{A> zkB?xY8}x4pG_?QL0z6u{P$}Fy2#{`l`}&aFs*6?}b~}GTyVI&SwNM<(xnq?GsbeS+ zS7PJ}C({MvCr*6I85851dH;JA?Z(C(v9b(6xEA^)c=tGG4( z2!-=f%=ic>QpYgUbnE(XUEZ+FgNu*tu8NWy2U0;$rSN8`PgnpNDGxkwmQa6!pwm}8 z(`Kzj#=>x=-^lBM44LlpiTDd@yuHvwJ80#bpe07VdAjG|(fGh7F^*$InS z0g-dfwk8{TG1n77t>#u5x;R#Kko`q!GJTxjUO<7x1nPGC?IORM`*(YMrz0C>AET%W zWN@akqn_f^FHHZ#OG`z^Nx1ld1Eo($EG}Hp$bDozcd4-P;iFW@^L#Cb1$DvX0#U**P-~D)*Ji?!5?r{sG_7K46u-NPuv53{V5Z|W^--d6a!)M*Un@G3kRW=5hn~@FTId0IBFhFq#p4`v zBDMWzW*c%E=RZ8F;^yXt9`6#Tx3c4lb-Voh^jL05;*_~S;4$}cEfvW;ac=WuRYngF zo!h)fFXXY86Q0bcby_q`J8e8^Z~t}7^6W%D^>9OVdvXeI_$r`$DxU1Ie0249ZnIV?|Im7#o;}u8n^=9HMwk`29EtH+m zcF@OnqY8$V9_Ayh)($_vWSZ?|yWa(J)x{P}*aMKzzX`p>zm@(a%`3M+K!IuX@L%R)v7WNR9o97^b`UA7GmF8}*yy_PAb(#9sJ`Ybco+$|D;Lw0zJe@a>f zDKT+^F?sAA{VQwQv~DeiO0pk@MUH=HXc#P-Hnti`kEGSl?3nm;p{8mirCz7B1;(s% z9A5S6gyd)UflixWd?zq0OvZTWkC%TB3chMrge)$*EgW%RXD7zk* zO|i9h$c=6Xc_ef^qLz0UH$CsOC4A(O$^L0iu54t5Qz#m8ajZZm^AdqaPcK<-@H^`p zxJh%dfD;nZui-hxZ?>_Q-@JI)Y5frCLjjq=zbQh_gxOBwIXXN%t0f)rvUVSRC@o<< z8bOh$Vf%CLeO!z9U``hKZ#@dPwUkR)tR&)cvl+yX1eHkZ=A(6{)$&%xfk3Wj>8ZlTLDM5jHFqiCO z(^_k;t?gxOA$6G_qDLw5vzYPS0CY=h&O~Uri?!BV!?7G*n^$hRO4P)B5) zT3`j+eYpJZU^SA}6HIH0sTR4g1F)4<)pESb1jRL|+RBdQ0qj2&qbq`_>?ieB)hgtN zaQ*yvP^H5He%6B;)TgF0F*p^6^}mr#1A04a?WSNwemaNeuH3qHspbc3x2HSCfuxT7 zKIh8#jQscY^z=KWA-L=(+3F2(s)UkLK_Bhk!7X-vygA3p=Ye@zVXa1O4fJ4;)SpwK!Kbb zZP|suoI)z*uuv2dF-dZ-S7sn|UyA=DI>Pu~&T7hN7VL175Ybge;K)GapdR>QbaiC~MLP zrnl_}(R-ph(!CRG%^LBRWvo(kzUX3D8F)!zCD~NWl5gJh;ZWGx*&$}Q zYQ4>sc}0;{!9k#p%(ebhb@;aZC%!V-ydDZZ!EMQZ?x`&+r_z#3BM9>>X30onwo-}K zF81C60k;)^3}FrwY1X09by$mqU}@+xP@TnF zHOEv~RzUFe4-;@iL4{`J{Q3HdD^&4E|4p{2ZdS=qrg2mbbfm1Xeun^U$F5znEDogk zE7=&B>*1X|~Hv;@b#<-P=$K5%wcQ2IKW@>+$PlTiOn2ES`%x26gcX!laVL-hwLoeSI|E_3& z>RcaNQ0ujRa_d80tpW+E5+(s0iLlTIboJdi6FDE^657i#g3y3<65VZSSGP%(tYxJ? z)?8dT7GmHEFtfn(Kr*?`gDRSnltPJtA~O14SrcSqM3v_yRo|%37oNJgy6#{M#~>6< zM5~X3UNf{u$=!r+8U65Le8%nDJ4ozcllnl$<9K8=EL>;Bd2g=!d@XtKThj3(!Bdw~ z3nR%Dv#Pwjj{#e>lu(6h@PxXOWk1w@d5uwwp~#7`%@s=>nFw2Q^|azfH!#j@J2p=I z_wGH!uh$YkV||Za2X8H^SvyK!EuD(=14LB5?ZzF_BL8o`is+ z)AN8~ink9?^%qTF#MEgax9vr?Mmgw!C!((}vW9fDjpeTM$*_=#;hyN+P{uiHaKY#3|s##P-t#;M; z_vc4VMpsS?D%2w17A{W?6kI%yvzDlpA(5C1J$%YGuP23??Dpn|d*V^Xum`i82bocK zAJ^*VGrg+AmGXuiG|9Iex;NSJ|_p3s6kBhMvgX38!Hd@X{@?SFpc^=F!RXvk`E zw51aP=Xn_Uwl`vMLppvOygnh;wKTnSe?$61ER=SUbuGH%wzaDLa zhnnHGO?+dIMvxEZdms+PSZ*By|6po(W@fu*ngyEYnKIHPXB4~10L-9$!B1MYZF`Np z_VlUx&znq5)=Q)K{n)h?{DUlo3DHs{YmPs8J`2yayWO2M!~V zYl4f*5Ta!$w;a9jUIt>^Q-8f*HOG1u(bC;5^e|EOq`l%oD-r!4GZR;g&QwdgI($Uz z(FDIA3HliWWo$EE%kA?g`v}y3{l%{jwmzV(X`Ft@ZDvysTTiRA9a|b=BGxncepByu8x$j7M(*dmzi}M~^iX&=<~S3M47^h`zt=V+Yd$vvESe1?ARbPnVOml^ z@oh;(idek9d9%7?!3Qf0)YT5~0ztpd+&fGWg>-J$l{SM_No=ibz~bEqyz4 z5d+|}(Ao%aO)brO^=+WTAW^Cg`n`W%%jeqxHkI|jit6KAN$@x|_0E~av*|7x%g)%( z;36bvt^IjfSvyG)VsM7~dum8r;~m^LsU)#)5z~4;w(Pm!4KT^EyN}7wbFjW?+v#!j zWId01L8NJ1lQaYrR?)vVZQ5N&$Dco%>++gD^>Il_Dukm|QCwp|d4(CFVWOJ+zU6?Q z4fJ@A*=*v%7a#SXA3nPgp)?_Wp0`1$E-%!`2*JhDP}@m_D<0Cxg%4Hf*Dwm0S(JeF zz&^;@_Jik#FTPXw<>LMO2Lyuf^}R|f_Al}{zDnwyJG;osyMQa)$0`5(0*&{ROBS*d z2{wj1MpKr%(Bo}IMXf*JV)>h5&r2g_-s@enj@rI7r6SJCNpq=`&EEpVi_`k+;E!G)%uiirid39H=;y!q zXuQ@X1OwzzexRV%<(4Y}x>D7cCyWHw)-#TrZV{DZ_ALW&pNw5sT$br);cvwZ19e*c zSbar|Y`l##)S+WXz^-hy0(W%xht9P-1`K&>(Ij-+@YOQnNr9I=WDF?`?zR{hy@aqq z{JR=_Slf=?go;GaN1Wd%b2k$dgjnT=3K9zLDc;pzd@L7X2D)?q{xtF}8q>}L2kv5s zitbCJx;$nZK?8&V@k&;eqdK4qT&bX>u;Cm7ykr^EkA1s5`O5X{Qjviou~@}(#=Ay8 zf*+{UkIPHysCBXzXn*dg;_g>K&-G%=-+{&C7{t|^1xLiW+K)x!02EA??M@^u`RAWm zIGJGVAoDxNuxH}crZVeE|2PYLg8f7XdFL;NMUK8@KL|CKKZ_>F9uyFTbeV`TcOE<_ zI#!_JKeV*svozZH8JI1&6aq{lYghT~vZVG>DH^)7N$zc59ooz5CE90>p5V+ z4(#gZDl2)r02WZI1C2G!t68%i`5xXect*fdiu|0yqC`cf1TD7S>#@ zgW``oIGD5_YlFW^n!Ghbjxr_X9)xQ=-TQ@1hm5b2_3LQW!v!OR9phb^50NheZbiN<0h^5Of&+^g&BPRf8f^AAK zO#R8Kv!1kLPdTUjaLDGFGP&m1K3HE*PYm5<1oOg$H8FOd8FAhV`p9Uh%X15l?0Vk% z!qD>7=7QvtB~fNxA$9)Vs1eY(n%Sv)ZU2Q)U?dCRvN4VmB@~WWe(mHn31DP@JGd@V z1?bL}&6|&c4z_=AChq;%EDxw1LhM!QDe?YCT_FZ&$ccTx`#^R%u76Tfkmv3&IV6H{ z_8KIGD6V*EJCB|s!liLbr_FVttCXZb=nsQqlV8u(C3dQzKN?38p(vvWD183>8ZHnS z$Z0H`ra_gm!&pDYoIe*}+1|pJ0}*c2Lt68zn_0qjKvt$nZS?7vp;u&evlOe4PRy{tG1ClY}&f@DW8dEA`4$x zbaN9)_%!QBXi2~L^!jlg`~OjIN;DM!8%#U|E1ehMx`BA`7Lf_9rl^bC;>Rp64xrQJ^pQ|17aa21)uz);0wb7SKHD~QqycFp>P&u#EdH$LIx5Z=Tv_kS(%suR)sd9Ic_^ofe+9R zwBn>v#gg(vIpRd?m%}0z(WBPf{?-O0QnbWJsDT+|W?X2qL1-}F8QP|f`Xb#|Po4zn zB(*=p44Q1K5gv@gnCEz;Zll(>&bclX$eyp_w0yoX5?K{`Kt@~WAw^tB%tdPPMp_$O zbnYM!ke80~pAR<9`&0CRKA6-2^L69`0doNA6gxsg$gK1sSZ&v8jz?CjhF zuN?J7eLSkZY%-cadWqTA@7q2YMd=q~PCv4R z(m5O!CblgrD@&8i&PkK1}E#zG9xMzHv0X|*brlX-Dx>ld&>@*iA*OVRXeEcxc(;BQ*tpg)v^n9gs-{U5!|sLzALFSKzY)l)j< zJ7LR5l$0S~|2Z!SiQ;TdbXXGFXIkMUK*n^)v@2*zlA$1FbE8-A8{R{U4jnQ8RyJ?l zI)^%~+0)yPgI8mTF^5Mfm@?IvWONFD5BM#?zDY-U&SMo-VMooqw%#n@gEFR&qO_pC z4Cc(4c-W}-%M}#x;KAtg&j3jX8r0h}m+dacsfvw7JE6ax&u?lxkj@p6qBoUIOM)e` z2a(?+?1`;>c1QO?KM-`(3X^bTkTk+c6TK2rAZf3EHNn}n2=jp5BF(1C(K8nCGdVfb zWcFk#fwhjObsy%Z9yxU{KVL32wrWn?-DQKfopGkd2h0AB52KbOjEtp>;;atG9_Ncs zkFoK*d6&Y?J%+HCR;1@y~k~f!DRedjd~|Kl}AFocC^1qBAqQoR(`W-o7mOEl4H)V{J+g zyS@aRk?PU@?lDg;KQC+J#wS{(mbkY_u^=rKzk>33CnB)t z!*(l5(s7L=r`9Qs>Ppn6L&~>pa>&|R*a}gV*-ip#UyS(vdW%P=zW@nSx6UF>YWt6S z5D=^`eY0S-+*O7_lV!{+G}O*NgQsgqS{TCoJ)Aeb><4hek+sQNw|@H==f*l{BjwN; zi>|CRnlT$32S^acdt&U+*VL7^a0wE~sU8j@4riIW{elzA6$h)@W_z+~yrp-rEFpK; zqILR1j02H|q~{l~2v7)aa#{ZAdTACP1aaqawNz0Fy^}Dul4u}hH8U2)kQ%}e<}BP6 z)eHEgD+NBW3D(|%!8N)zJK`hpG|!>6@nlhXO$vQhqym~P8X+~4hr{3=;mIyZvOh7e znWEDB1=@w{k%S}c`%gEHu7$nH`Imr9i#+o$tQkp3uYKbSgran^`rFiE9tLzP)yI69 z;hU$(n{B`|M30&1YFH(z2D6f-TS_^fEdfyo?3Eou%|&Cv{345B{wDB`pD^K$ zb63UF=`(<92b1F!Y^sqf+J1W2Y{yD#6(>enM=>*Sq2^oS*dD1DTfIxbSr3b9}zUZcQi#{J{^* z(3Dok&mb8GG9@uBJ(ch}W*Z6OVU7zod!oO#AK=++bdsbbac5!j^W4jc%=ef*i+#>I zPfN=eUzkmN?eN+w&#D3>@Cgvq)$7;CyOovq8X@{E&b{cj($c&zHb)X2q>-@b(Yfow z?Qz|ZHe9)MX&u^_trQ|=XYsAs#7==d6!g+OhJYQFT)o z99w}DI`y3a zMVv3-okO|K(q~(1t5d(4rMQxXRcNgALT+b|e=W;qfqo76j{X@R`!{OR#0>1@Xn9+& zVD&WGf8|jO6^Ad=VMk3ZU+NX}vya#WjbTlQ$WV^wcU{rW?|x&!kXa3bg$IeAE?CsrLO+>z0->VckbB}#)0bz1Y*G0@&~Q_ zd-r;xJThsjHar~1Vs+_Fq{795vnRAzo{w|&m*vSoR*RP}HxrdDJ@f=9EMxGLU?Np9 ztmUmo!)z}9M%_OdTJAJUoMItldQnyEudPl_h#Fi{P%|AY!Vf{aSyhtf`t=V!xLaX{ zHu7B2@|PeX7GxDaK|IH`_)&LcZyy~KjZTigS2kGvQ$fYU(?_GxsU=^#7M>qtWH`Ly zH|iqch?ehkgXg4{hHJU1y|3KHFCgG18(YEPBa=e1_akm+QvM=AR~GRha>H-+UpnPO z>J8awk)`AP5&eG<6dByRhV@A5S?Uv7+H)yOFW@-~Th6ITW^uJFXc3Gwa2|9O{%W@{ zWR^ezSt?$VB$@B`{VTT7f_W1I8zaXAY?N(mymd~#nOp4#sQ4Xd?NHxcK|KV-Ama#( zajY;b&m8FrhW@R>eZs_v(eIO9+(BF@iIP2DQNJ`cj@PIX0LATLSdlk??qHGLrAvt8 z7Wun)S1!d=Mx#h{3IuMn#+E%2%F4>{1yn)4Fq<-dxn{`~47aDy*kxh3?LIC-i+_S` zWO$nK9iGf#iWo59gVZ>WDqWa$3ZgX|VtQ-#5s?B<6;3d(cCCd9$1wE24Z8 z6jMhE?=IlGfMjuYqzUvh&%HP@utD8ot02J#oL?Wjxzs}DoOwHQSS-k!%e{B5StBHY zO5kXf2M@0hXpE(#pg=@>buW{$5Xebr!zqS3p6GdS84n^3uEB?9;=v(tCdOkeme#46 z`gi!JuV>Gk!MDJN$PZwa|L21kjfN-qJ-?+H&TNl*35lYBj2wX=^@h~e5yzLm2sE`A zbv6eu6=*5ueUhwrGiKmQ0Z-3oc}#fd7rEW3nC?cN&t)qyl5d8?;{FcrhOi zAC~oQSbDkj{ffp}23Htvy@W<|5v8`#g1}DJ8BO4CCZOsJb>cld1Hl2ew6t30MyaO+ zOf@dlZHt$ejCO~QY;tQ&(s-zn!`$&l{ z!=zP7G1iHvOt$&gAI-8~pi40}`TxH5?%iBV+1hSt$^QT=^ZPQMA;`tpJQ-YAYt~;= zvk>At_C%7Fim+NziGY*8T=n`3P8RFwuTKC2Ia66) zO2Hr91L=S;xSEopNhit7oLc~SDba}-@58vOY%IoU=78xyL4<* zq-rM91d}-YUJLlb)6CefwS|VYu%yH}Gj`@4gwkX9BlbCwe*cSOkw>=$o}Ec&WlZ_4 zOwox#LkdU62u#rR`GMhRtX)C}P*zRBYoXMwd-o&x75v^%r8G*s(ylczC^Ziui0DPd zxO{}O`w9ki2*Y~qv>bgOY0}x4xkax^4*AoNPQfqGtV1{Vmqjp=xjteINTi)%4D+u7 z=@ZJGGavwo0fTDsK??toYKzwNTiR*Fsxt=PF4V-oIHru^{p$!1{ia zfW2m}s_+cHZLh4CP#w61B7pYV52c$rSc4Z^zKQTq}Zov zXAn9kSfgn|?}gTNDB! zql!t#bSS zS~QtvlUf*{`b3`?x!G(B+Aa3P#qnSDtS6c~| z$?OL}V>)E^diY%D-v0D_&Z_{)#uW@`k_*}e#478Q@Sc5=q}nU*2>NW)RG)cCVna`v zxLeoz$5X1@I=Zz8CV4~*5x%?DWgC)g@yaHvzB5d99`kwedC-UDE7yN45cx9DTq`xT z$qbS{T9Q2u1ec`#7LWcnJbGCtN%Q@_V^nTWuO+D)m7QK^l1YJd01$w89rBL)KRPag z1IjY0v*u9nDe%3_U~GT%R&ijy=Xy$-{McURxqPHMK!Ebr;N;_bIYG~^x}VgIJ76b> z*^wiqy{pQoS;d5Z)|@$4LE41|o8a>$4LveHdnvjoc&!&Wbig5g{Z>`}#i#pK>x6%v z)CQ054%@<{jA%j85N-Um zbD1iK-uFfCDu2jn8BtvFETbKxIa}6sxMgQ#d3xauKzZu)t9&4;b|Q!H(gZBQAi8-4 ziv?W3%F>?5$wl}(ja|%Od1yVR7gQ)X3hlYullKF4iBTeQOQp0m2@wn1EB|vp#)yak z9C`u=+kBr@hH9=)TL|Pt(<9fVa)0QEmsz2WNai-gIdE}J47%a7#PgM+BiDI&#rE`! zj5*Yfu#}=~mRS}W>l-vXu807b(b#+8xB^nsn$^E1^TJs_Eu$ozGgTX_zudhDM)sC_wBA81VA3{f}m zn|a*b-MxHjG_{x#;|VAW;y!p3gvh0YtI;Hr(z*th52*~;xUoK)2|E*NX!-E=xC}nW znmBzpkAfHTw12M*A!SH=wqHtwGd^Py=-&D)7mG{goZ3{5ZQoJ%9~9yLmkE z`o2$3KpL}%V==lC#ghU25L6|=4dZwl864%)R?}LwZ7W)JlA_PMAk}&1)cRz+FK}MT*a+_DAXaPj_z(ILVM2WGCKU-EX=11?^pjJK8=yf#{N{LZ15jj?;b|UYl9(XYM#tpZOISohe2}N^5BinD!nrWXR(uPu5}k z<>#k`Jb2XS-RtkGI4ObVr1E)0kc+(ZtZR#p;S4kK(GLLT2e=f9{c4zj)#dfy0Jc$I zHIhn~Y@j59H);~l2yrt6SdT0l_O!IrfSV*rN92eXVT^@{e*E}Q=AO>qh}&Y5LXo=U z!>efv7C&Rdqq^6>AUdo%m7)7{AM%}KH#6ci_f!Qtm|cf-i+~4h6Nf;Qpcwl>n@{9h z0ODZTw}Ze>L%Z~Th5M>iGHJw!XHK0d(Y5UF9q&fO45E`_)b(G=nb+&4e(n;9GR2m+ zBWqyY`k>(JB8b{2>(jbg8aokTarC}TfN-ba<)awen z8!^fI8BRtlF@U!J?Qs4*FoD;OK2jW@vley}A0rdDCr+|+PDD^3c#zn~Sun!9$;a!+ zFTgrb{;=OF;{6F873IP7h;XLmFT#6Bxg#Ew^k4Z^V&d-XoSK|m7o7yVAi5;M1H`Vx8 zi}6WS7X?(I*0$cvXu@BewC|0d*dpGx*ND-UNerfI&O{9b5Nk)JOij7^v6q$-E$3`z zABI(-7I z7tN^my9^s8!iqx!!)?9!tr~uj+&_v$Dm1t)QPZNa$uId_RkaHjOP#k>ljV%cU=g># zp&;q}!Wk2rF#6#udNGou9DkWX=y`WI)PuN{|F0pvSg4tfQBuqB!hx<%`Ych@n8wcO_?j5dPa9_LiEwoFtd14y zWT5C%_RC&69=fom49}IChd;Fw-9R$1GfF?aS+ouSnXx+zvAbtV!5W$CqmFTEANp-3pV#Cpk_nq;VC=BV^Yfd0B zFw3i{Ni8oq_Awx>xpBMA-3~XP>K|YNIT!YR59+N$_=>AYCIAug%&&;&QTpeL`x~~$PRj*|W$gl?I-2WQ>Dn=IJweB}# zdOg2Au{>|7nuV@ni@<1I-G5I_P|Tk-=zMix*5_mOjQV*tWY1ra5yHA@&-1h97g*1t z#QMtQA@%aedBw&3sQsx3cJA5*r2ItGRDFL=ldW%_IjZFHe#ilDJEJ#iY$jbAe1#Ci z=b;js&@op=Pb_A*dV-kh%q#A<0TmMB47{e^Fh4Kc!Gb+q6{WlGCX=j$W8MGy>-61y zT1re-JVjt4lP&xGBYur*1otNAzA3&MQlI z1;{HqM*Q>}pj-N{Z-#eM|+;r-c{wI$75xs8XgdnvhPCW1W z7m*8T9mPS%#m#Nc%DGK0f;c3&R}H4sc0YAFJ{(0z2gZTW#|cC``QVVCvYkI4YlDj4 zwA?Uc-%AdIq*~>KK1=XqfEAd&yu@t6e@PJ}zbmV|K_0?`hCt$ooJPlQ=^8V}5As{W3 z6(8G0<&9vM3NJ|{Dnne}{6V}#gJX2x?$?_yY~j~88uu%vav*Y2N7j4|S?tc$U?vyd z_(=BbUdj!n9^*foy}jL2dW5%?YKtCDULC<=9&QrMqB;KOWgnW&vDQ>q9}!)PuzHo@ z0mh;o&doUH{_#X#PhL+OLN%_{<@=7t{*8uIL{YuWqi0byW5?AxVcA4Q!@jrh1IOkQ*j-_0@xE9I%@%i^Ok*Wl|P*a)28U4g`C2U>@5S-|P z5o6f@@52>_hMusQv~s1k(W56U%({r|t?2 zGz1*^a!$i6a{JDm)Om}8+Wmtl2 zJeskn`eGTBQ2Gf&II#zy0CGQCWjcpQEmST)l}R9(_r$}g@5ydwf5r1OpPS!f2)0SX z2SkJJ@%ojZyC8iiIE^|*nS?e3v&ih2>*C@ffCGw+mj=TUkE}&r!^M}0wBasq)`FBs zAG+%E@lz9ijYDX3bYIZM$Z}gh4{8zJ2vf)PS}fKJL$_yCqp2`YE z8KD)|KmjnA=S15(=6*M?9vCqef$IQ5Vw#>wj6-!UbvH7e$~9r3p*yhmzI`TfI3F+a zN_#qn$~|JDye2Urfn~+4i#1Nj{W;;TvTpJQ9-T?i%nuaCUX7iYmOyB_c*mp-Yy~;3 z86g1!4eD{s_jwKJPXo?gL@l?2hNfv{(^Zs-X!Ig!&V2% z7~LSFHGv4AXUquDpG4h>J4?*wlMipUI?S4sf49=v057eWa zFKJvkRzLK#w)5s$+$@h)oYZq|NgtG@4)Y&2N#3X>wh%BGy{8>tkJ^!BUTZiHrKkvn zPE-2FOfy5ipy>BmDSnvCfY+8zUiC6APiJZ3k*t+at`?4DqJgXm2(zfx+$Hmk9k|~J^&=jvo`E5NR#Ly`eJXp? zL!Mb(eOCJ)FPpw7u`O95K*Pgp7G*%`u@qG8(08CV>0P5Ej6>@2apXWVzFZXg zI*MK5bBDwl_-RlHvslFt-OXp<;G9(azj?bz;FB^+_cI|#aVY3y z#_NceVEWU}uharfVI##Z*cg-ZE0@#X-=N`$x1QlCO$Tj*7!}j+22ru#d$N`9B119c zWQ1VYvHmN5KFrnv)^@d5-#`wL0*XW=0!!u%0E<%L7Jy)EkdmHs%xOr!j6?2akPMl8 zS#eL1P=efSL@)>~qG}_wHi`<>5|xZc*ztx?&LRe|Eb`dPX+^ecXKvxAVJ6eDpApud zL7=?v;b~3DfXM!_f!soc%pDoSjx+QhcH}S$XRG_&94Fy4%(DqWKpR zg?q0?xIqY3$h#N{u}$YNn_mj)eVc9LsIia6O)<9f^Y_1j2u)laQ6@9^Qt|jw9jOIr z_=mC)2w_tpGJ;rTop~CXctOjYx|m-8zeuu#%(UVBqAeB!RnA_IfeRJazMpAm11IXX zhVFYc`}Y^T3mGe+wn5{@*;5-9bIqv>8&#flRU^L1ycvp_)|R`w4XRte{t3`!p3}6% z6@92zp|R@9?WlaoWYsY7fmyN7t`x!=)~y4{m$CD)z!B&=dytMuX)>q{ND^=TY(hGG zHc#lC>_`T=pyt)1Zk4_5K-(g}=W047PW+KVuTB`%;|ku(z3&OunF01wJ2uRabyHjkqu5Hq|53#xtt9gGcFEZq(Z|7w81BFjt~ zVR@mbx0-HLpl;^-z7wrKkKbe2)$eGwlw6CXsP z2lHx&5S7aO6R4bH;vj`cr`w@B-@6bc(6hFxs;!5fc*YfjNv?GZz*elNz9pTzth$!J z`Hs&y5NfH?rSLOXrUE7&i=GxVJa^Bz4wTG9q~miuq4+_M2Fp;)ztu1LC?W!ru*n@E zm2X|NoOpN06$qz^WURY0%cVSZjh~UNqiBSLSOB>gFy~rxBEaFMyA(}J@X2L; zqnU>=TGM>>x$FNJryo+PG*Ks$16SN6m#o`p!`Q0EyN*E(S>@25e_gh0Xg>UNy7Cbt zb@^RP)eKluUD<~GG5^uIeWa}lU>iA0=qGR>pAC>B@&gX(@VvczBbj-o*_E&bdFB-o zGP|A5jukfoblOu5>INOc%P7C^xE{PiP4_R$_=2gZEbR%L3BRpZB;z#0lFO=ubGk*P z8^=;ET?)FkkG@W~W3Cb)y*};A%9XZr=b9f)91KlhLH#Gw)qeNe2KQ$;RP@~h#Gx3V zIlq2jgZNRT>{xvaM3+XVgov`+ph3QriUAa=2MBR3AC5#VKm`>?i7m4^FxTmyH_wPh zGRuTBkHN?MC0d^_u8$Z-L@oE#=QIpOb;Dypwq*ac`e!xYEoiAtldlCP;bAwT!FS13 zlZ&oo;rW-$LlGsRLFi8KA;0?>`~S6^m$CN}4Rm&T?A0yvX3rjj9CI($D+EqN13K5C7hajed7h!VUW(DHOWf zHDOyfgVc=+nuekqSRXk3F?xO4DLP6!#M&|@DTx<8)iH6t@g=yvcgP0> zQ)6f*s%(iOlWXhtxT4yq(H32sNydqzYth%>4j)rtiFy-(Lo*(3_EGBt800Nkr1Xls zPL;|)Oz=u)4dV&`hAco=c$CZJZW)3G6cou2 z%v4s;h0i#zyKzl2o+PMmsr8;N5~gC$5aDN`=FIToc&oH4KY{i97H2HmWD^X3-t zn{1)oMbkKS>fW>KN_i=1=U-zNU7L#v@@@5c_U7a8bEzBvnXv}aDAwNnovrYKNM(h) zpblrp$FtJ}u@bu~#4?wE^4mp9eCG9@i8mI26O{M~CYb<`9c~?}Mfq9x5JnDYqlpF$ zE((mqB@yt15~bJ4iT$`Moq(9rNDNS|F}v!New!eLPfP`X5tEO052cvN*f1<@zmIuD0Bq4+}dI2PMiVi zyy0Ep4s1x4l<9r!JfX~u;U+a*3+O4PysB#5zI{|h()k8xctqT{TUUX)8jKCQvLDBd zN~gM=`gWR`#8~w2homU^7FCV$63-aL%(?CRwBG#lyE!EbN69{+-}#nyFOg7^9$`2BzO>^Z*r3&@`gaDMqxlh+Wz_q@A*6DK8x#j|5| z`b4{~>S+oI1BUYqrKsY|)}?A02N<*RzI{-8Xi}!qM@OuRyD%8UqZ@i*+PqrL#)R-O zWchUEP>490^JkSdQsAJZJ~dz8HB&+psjZX5LDFwiuO;QrE6s!&Cnvd4ZeV zN?`u@;+0SnC4iDSz-6Lqf%Cz|X*}OEd!6Alp5d~fk7YP8*-{MH4c2$ybhJrma!vv7 z44?cxW;O!912zQ=JM_P_bWg2>L+-X5SWNRjcQ)5b_FaGuV{2g2Wbs1Y#)&P zj=x2>QRKPi@$1_m_32pfpjeB#LL7jpNMc)fp>41MrXp0pJ(iB>yKT*RrUydRM&f61 zEw7QP-7sx!TjsEsw!|s&F;f7ZH~UQe2G7%YErkibOKkt#LwzT83uCbqhMv3os)U6r zy)Z_xnZo=_k-HnV?R4KgZ&#=1)0%7T-lI69V;6IK#n7#RSYl#Q(ChYxhi~3^%z&|w zx^sDH_7gZ3y_?$V{rFB{{B)5Csir54O*R87V%&__HEX_&0do z6zv$fLGN|eAlzFXJbZ{1R-ejGc&d2L4e&?D$C$fRuPCF|Zak5rw3>~=-b+s$KQ2Nx zj>Z$ba(+`AY}D8Ol+&zPqqqdwi6eDZyDtWyf^RWjGc(G(k0?OCJ-T*n6Ty*~#esKx zf7f*f$52Mk7-Y#w`=rRj4}-z0nHuF;dwxqUc=RagZdqcdW+1&A(*fA%_gNq95;P%5 zvhgTj_}&|{TEOTOv*2Sk!J*%(SA<;|?2u_`9#XhTs6o(D`fYtqSvwr2sD_aF_)$fR zCQ$k|>SwK$4}5+1?Q18dFO#3EJqGlIaK-kh&GvsApo%`;(rC3L`Vg?xik_49j|5?4VPM<4kQa78tIq5b%D>=2y&@J-Z}^na_Lob{TSDKDQ{`G}89;YUgFkp3-FF(l{b?rIp@CmtC0^3|QNZC}2t10l)4r^N=Ih_o>_Ha2Ccz(K6vQP&V<7nxcJIUlxl$ zCQDu$h?yFbdIt7czy?^SHUp^&dHtfZ#u12O%0|xKV=_J=!6C70g)-gAoF|t(VVj-o zzH+vYQ$^7Jj04||H}O!!sngG2WvCu9>T;(?9}f!D)&vRlWznQgx~tlThM8@W8b@Aa z%uXm>CTO0|TJgaIj-iNA!zbh!%L5Ue4d#K$SyruyUtPTt0N^rTKz+1A-5Y#WDC4_z zO9(uwPf~X69?e%r=0D^4R4}vwfBn^?TQ^Uj3(|gC>>FEP_c&aV=xo7jzP`Df+9tH9 ztn3C_YcXv^v6gTuy~Va^C^}_sn|g*ldH;NTZC%;&SQ`g^p!8w%FSohFZAK(1zM}Js zIYRw%Mnyzh`I6c(`DS!2ulbq?YA4cnWKZaNGeE~mt=mX5kv+1@kz`_4zO#$QQ7Zal zC<@swerav3Isp!Qx*4yQNQrF`nya~JN;9*kes+~+5R(;3wX3A6na}V3eAQuhY?>U3 zb9Y`m&-|Sjm!oP-rA=}oRLB@5oyH6L?Hvp5 zobAvE{~&UvF%K;}{}XxH-~Zf$lD5Z{`XI#p~@D zcEZM+%xZM@*pV}+D^Q$@WdaJNh68%pf~oOkTB)i=R%{KnbwbofA2XK_IRD=9x`=Nm zQ$Jn})Csa8(@53>aGnF`Eu#d)$^kU)ggM~0AHU4Bwsyx{NKO0R9#}1n2{KYnbpJ@C zh1Kf$b~Oz)2-2!_?faq zz>``5XF7Dl9|4sth80Ff;zw+wY?D1w2w1Q2L*uP|TgXIC}Pmy|<2nx=R@1*0VP5F!u*8UhJCr*s^LZH`n~W-OrCQKt9TM-q7=Vt;cL! zBmZ*NPDez%Xmy}*o$T0|fsh_Cf3;hk&CJAAMsB4OMmd_ZVrbz|z!cde&X8&{!dwx( z!7bp#y@UHP09ioTx2;~s_uz6Wycl&L<*GPgajf5x++>>;y{SG$EeYV(iijWQWz(Lu zlQ(LO3Obg;526!kqdhao=<(~<-?H^%nXT+hG?aMy%BxQupa%9dY-bMnTGKIpYsvXw z=yNE&VLT3?SefPIlrHs3ykkzdb>d)Rq%Dnu-a@^80fs2x)_nWi11ahe0Y8)7P$BSBsiE7zhZ7tsgZhfmD`7vINb?j;NK@izIAZOXx!IWD<^-FA?Y_v14KIS`$_jN$hvn75#t5~ zKDy^eu+L}+P4JF9fVdIMtrkK&@XiG=Mf#vpIy0y2)hn^%7X+D}m@7ZM@hwDGi^Vw3I2h$pOR1^8qNn zX47?mJ=@StP>~7Y`}s509~1Z#6>r{LWO;PDp~)#4LPPF|Oe5ol3~LyGS{(i$yVlW- z8|%~f;3_`0qvQD5vlMJb-&;SPGBpfn^`IHfEaT|eldTsAb#IK)89p4|S(_MRcyOH& z^_ocTCqf{vjwN5Aur9oBD6lYT!l>Gks~&XGmQN@h9KYf5ljEbo z-G>h!E}A38eA#Xdrpp?F%gAs!rSB`_Yb=;04gT_ya3L1}s2W)?>5)M|{Vv;iks841 za;0n4sVC-I%>N_g^lu%g$O@eU{6CD`rxWt;zS?@8NKn1t?O3E8yf_1wL#($jAo_f@ zxEYUvoVbMQ1zw)vLyfBXE|cYELJd(gvh>}6yo6NoR!eXroY`@1%yrQLw539i^zivN zmW#I$4vl;@YVu^C6s@{J!hSNk#1TMuw*i3&>Qc}zB|749Zr%5>0s4wDYk(`<_A!nh zP>b861BH*?q(`4V-blFliv;KL0PRDr%X$n3x<=wo(}^_Y4x?*Su~hgy7>R*Kk2v71 zkf)Bd3qmV(X=6(8?$NdAqLtg_D&aXbazHd+inS`8c-}}-r**!fx)w1us`tO?T-f1e z{&8rF+Oi50Xr6({Ejp}w+>E^}0JF5hwNxpk z%{I{LE9rfR5v35T4X9LZvkb(xybSYDtZ=xH0*Qfh&bGBRX=+&UReEpwDvUga;ZsnO zV=*%aoOUDq#Pube6=ynpmT!LF$J124PH-oh1C^AD91Uo^uVysr5+cYFa$ne^3&ea# zft?8CnQ$~&;kjo(sL6G3LEiNdI#2A?CjUo(Svd6hd|5#e`FcmirwGcay=Sydf0<8KsNlQWfnyn8gGR)B%PUO@z7MwUK(Zq#>P-F4nrmHsyP=Ve*%ll9_QN^Wjz^_6pP z&>uYH$^lsGR6OG30g3bL#rJ9|Q)zf8*-dd73hG0B-jRox1q+7a{(p5SdbNg>Ny@Km z-??P&r=?-=rM8HV4bQIusYh*b7{r4LhW(e3CA~h?MdtpLeg$VHKc<}jk@1fIC}&&B zM@vbm=k8u@($B+0!>`*y%?|8G)LOmCZg>DBd12u znqi@?%&?V8`&=R#zdjw&L!h=kc^I+vl#K(y0~ne#Em@g2Jd!hsyiaT)xt^&=mj3&O zzm4RxV$D#ip{JG-=&#|yX?1+hFpUTkR7d9eX*z7c_CRiiPkE?viFBI=19%MmDPNow zCR6@%FaI@YnTx1nW`>Jrq*dTFK;@Ylw*sA=g(;?x(s30SOvjd zF_^YI8EIh#EcaB5J7{r_kV>^r-}h7W(hZFFJzw@+e2|p1Iw&Ub$rB$V!-h_d+2NN^ z{}>En<@O={sdf5eo6buj_E^2}I(mo3E)EBOFEA4bJ0dU$u}GTPW$Y@S7fFe`_ru z{aZTokrQ61SaOAdd1VvyvX{BuR2Je!@t>b*x>CDSF8EO$Pv`X-4V=7QT1^SjZ?e{; zkLSvBi<(>nZ5hw_JNc%c!*y+OAYz5-Izgvs0`Td)2s4kfY~HWV6lrZ}Y+3C96qo~z zT;_UXI%yDk{Oi7Ve7_PXL*k8~eaOyMZ|D*J37FspAxXRy z_~6BuJkH__^VLS(58YhiyJLq`&%8B;80$3iF!VF1I|`vf+=SmdjXbSRr^wY*am_$s z2ry9jk$*%BMcaoJqdsdwCrn76=lWCof6IaI&!ivZS0hiYFJHd!EJiLKr_K`2mYLB) zZ&A97l?K)Eq@ugH$cSW$=ONn@LRZ(b7U49@IMT(55(TgPQ)($2l6C3DiN1l{7cRVz zv7DD~6g&J4s!jOq9*_pGEXZzU;)=iE!V^!&Ayd)zo9+;~96dh~N_{?xJzp0+F(Ql%geTIEh5S<5zB|x1-Yt>*>=2 z+UCLxpD?}e++J062`UmOR(TO5Sh`@l&?Zg|vm?#6(3c8JFVi-he6}18r*}A= z;uq^F+o&Q4et$xliExd4vb^n->_Dgw&)2Lr9aQ^w3P|r`xCu|_a?NGgk+h;G8yT%g zOEV~Hd#GZiF$yHYYwx#Hsa3cs$uq2)|DmG(spIOb`SRdkOwX*TNz&e~(I84XTTe6U zFh(?#Rjp7+wr}6wTdCysNbEk?jDvw!UAFST+tM}n{_s-*8r+*aGiADmjmw#_rQ>ZT zaSd5oJ!x|as6!BWLB?F2AGwCzssMF>1h~v-2M)LnzenX+10sar0)qf>Bk!7icolMu zDI-2Tu7l&$N$UV}wIx^2w`<(eaU~FCbhm#%RM(bY6K+xB! zkB-B24kFl}m(I7tv+a7a!{g-1leQkm#??S#NHS%%Udq&k3y*#o!C90ERA6Wvun;q! zJzI#}60>GTX;@kOb!LnrG55*(Y^V&jNQ=ZMqUrO!TeeJyOB{Xa$}u^&JTJ7SZ?fZN ztf^iOZEF5Bj+hoPFHi94Zfle}&SmK$T;WaHFWE#Bxa#fips;oTLhqqm?#}3T_Bl|W z)C=Gz%m0vXjAVg9Kekd$p8a797ad%nbYDAQr0l(+#&2v2Zr?T@ad*!^MnFiQ*_ReN zNOj)uzFKuTI#)R}t5%)Uz6+Xr<=(w^ROyi@d8nRqMvIyh&o7Sip32!jL5>!lrQ;ut zUjBbfoe5aZYxn&hbLL7oqNI`|%2Xktlrf|vijX0c%#k@s1IjFN43%g!rI1+@(jgki zRGG_A=40yr*-yOxpX=mndGr( zOJP7@Al`2`hy^GqSCx$eCx}{I^^0&e*~7!-PEljj#qcw7$WrRoYeDp(dJ|Y`fpem0JdTn|g}PGkS2jDJrVN zna2t49|Tw-0_YwcfoChc0(kR#0Q$b(2~-Fr&z@y)Cn%9SzW;|~enHi*mDJZiZm%j% zrNxFBokALNgrVvDOU8t{)!ay7BjCG@jsLfsJpNCwJL3`nqZNxrfz&VS{{8Vk50f`< zvD&L@M*%;AMtPYiha^;<17QBVSGU{Cv)H$LI%7Q8Lef2e0F!A_ZAm=@x@Wz`Dr$bQ z>Hrc3e6@Y0eQ2vFcnA`1_?^Kmh-4M{u8iDn*b2k?ZEzm^Z7aDu42b}>p7D>D(w^rD zbxaE(1irV<6HL7$r_Ud-y*ViMgbDwcr;7uI{4gj1F}`L~>o(-9pKi{^)Re@SHd~J~ z%c>JMCMy4T>^Z9+#fCTnO3Tb~PQcsD(4jO(HQ43-H`LA2qyl-+u2e@{yGTtA{(A-aEv@m) zNC>=m@!~f-=Q+BItXy0)!P@W{@ndm*+D{j99qqbTx#qH?BNolNDlZM3LWK(-SR#%!a20BI@o!QYWfkHx?#x>4c|E z9j*bE9j6@`^@VWs6lh|{Mc%VB_2>wM8&Zg}V?+^0La=r3ULh%|AKT-;_mcwg(}HEX z?M^Zva1HvZkfYpngri}sbCLmy575V3OhTg|ihi@;w}dWwRL3h4s3?+67C%8G`B}4d zYZ>|jMdb7}nKv$+&pP*K8uGQ!YafG?ycM#BSXAkF`BGPPu1q@D8T3fJv7Hf#Bg7Gr zILAke`we4s{<#NIM?*5B=o+vSps#4RyI{Ucu4-8H`#SwYRGX)f#^+tmL0T))0-_Gy zr?(QEdxV>L4P!a;jB@`6cXo);a2o+aDOfRQ2Mcvpn}y6>VT@76=YuTWhD6c!RADwD zQ{O$lh#a7~_=e+n@b~9)sB*!>b8yGlW$x|qO8aGd@$Qp*0c*lG`yd4@ZTFjHJ}OIH z33?qrjzkYq6D_|t+73)kHjR(ermHtqeCNUKgYZ>D) z)fHG}&@ihmK;VVJQ@+>;e#Ne#4Un!4WXdp1Z<$q`?QQZS2T%jqR7QSV3@^3 zo{Jc+vES`1Zi3}7ZfZRm-30(j>W{0YOLdQ9s%U+EUhG{0aWEB8Dlt)7dF3xyJttic zsqP5hyH|_QHkBm?4I9YOFDW+dHF3WlK7cHy74^>>48m(x#k0YoH~nqL)dCD09e3;y zAQwWW1wX!49^QAK2D7q)MCs~?t=;M0eYOC;1dwP-E~vE%NR4ikN(6Gz7>jom#c7f8 z=%6qlAvNUSC1{PGLNIrpa9VtV5K+p+0iL2hwqJh;h)M_6eh7iE!8$)8?SL!_NYci5 z$Ls@C;#dWg^7VFo$HqFIK%h#Ym`*`vYcXiL^l}nkWXn-XWo2h?5NH}Je6jn8k1uZ+ zpFvX;lG~?Y*hK(^aT&)3)bm9Bbr`uB=u8yE_YrI&Tvq;zP9guOXH>mw9D*i~#zu?> z#SldUi$vz7Bc8?8sx`p-eH4N35&Ftr6zh`0YY!z{z~m;n$o!~3U7W7 zh4IX2SmNa(n*jKUn96Y^Z4aCbvm(0NyMPHxipon84Kwf=e$67%J7F6d-jvPm_Ahf`ngo* z9#vMhqeTgU)0n&cOgK%?eJhJ+cD*);A(hYgcC8aA>$X$A2(dsFAq`MhuK1D9j=j2U z1J_N37}oTgc_!%$YgER%N?VnzeE5XZK9!MwIww0ofjqOyM-J*+Ql+< zPoo*rreTi#N`3EKI3ba`ODu)o8)gw|j22V6q{M**eDpn*h)rQRy~4)m3Wj|8G_Hu* z)Y<4t8=P76N?pNvayjz!o-+-*w301;`ylp>LwXO!{kfq{MYZsOP87~pLBf*%sLlbe z*>3Iy0P|;Wb;F~E+Jz#DY+=gWxs&29m_kdCuFr#jQJ*Aj1EeyjcE_!I8~oma*JsNa zL5?n53d_Lb>_LZ4UssP-Tb`(K<0--J_Ja1M(_6CH=}n>~CK{X(^!I-dto2WPaujAA+yK(*cbSA>Y#!u?$n>R37acosfk((HrWTl&Bt z=mvgXwCumE*oHspM{)!m901mZi?=fHh4_!=Y-cxARANv@^SzJ2tq`^*EY2a57%3>JGPh3l#P**zPeX8-Z)_KuC4KByD1O$xTQV+mXJ|%--}gmzn?wz zPeD=PnR>yQ501I5olHXOICiY<#|P(@ey9zM5kXr)^%VW{uU}axnSzKL4QVi8y_F z9Ae{UdHMNuXrYPqIQlAy7gq2IQnQAypffIo-#@<618K-h{roal?=mV;Ky@{8tByEo zi*NZAs>V8|rl##c_#?xKcX}_eh$Yjwg0RV0euzT*3b;rek~*s~W0IYZP6d4RqhhRJ z*)_y*WdMN3F~UO)U-93Ye-=|gnKgwYZgYgd#uiK8+b|(rLu&6Dz7+)f0*@JB4)_60 z_`7pw4Fo*?ul#cbR89@xD4Jnr z-;oM*dR!UdI9fPtSA#M6l)ot3r)KnLgIDSka@8am>bUn2V3Ab+KNV_@8pl>yJ z@Zm?x3DC{pBU-Oq#TINF(6_M&rxli`ss3zkK70C9g;VkhG1e$|p_Vg*(E$oCaW*K3 zHi%HJbk>QLO-{s?my39ct62sOmUo zOdUoi1bYDRZ&g^*P(3QKoEYF27w3_brip;|a#q&ik>dvs&T?_f!4;&PBIe87oSQf8 z+7#rS>;o&FX!h*cGe3%q14oV+14lOS(@}xft*H=XIJs!zIUjpiu@-T0ap{HnE2}&v zmIH>A<#kf=Q`OWgD!$9>+-vZI86wT0#Qdv%zFU35cpa!>P|Tfe8>WxC^x^z09%e;@i1T}DM^bY;k%+z!pzytKIzIm%R z#6N{E)MZ{O2YwSCg!>md&I4KF_)N5+G@}}ZR#f4uhlirnMgk-{j zT(0#Ua)Rdk1?O*io6zPD3XzG-p<}s&Jg6Y^zGv!7A4R1IfWD8(oB8iPQxpXOIx6aK z#z!S2G$LRLAfsN`hxS`d=s(DlN^;&G$ZE`>a1POX@aS$W`|*y5oY^ zugA|Lk&!hO-Fv5|^8c6u#T+>j5E?piZ{N{~?Q0ZQF)485YF@^u(W9+t{w;fe)_Bfh zFD4sY=1t9mi4~nhQBe_ggv|ntyA&Kfbf_+l!v>RPSig~`AO-$FrJik9RMfyqt&(v( zH579mUkDM}iJI@oouel2_8&UrzV=gqzkgn<@4{-4y|!L)NUyt@*^%Zlszyz1%c7?& z{QpLcdt9#$tqb7R5xl(1FVHTqDnkJ&f-`adiSbEt7|Q(YI(GXkE|VcfFT0?JS%x)S z>G=)|yjzfbjiaQiZFPy_uKdB+QKKxWQ1_Mts=u+H7(Z&vn02giUJ?J)exLKln@3qv zJ zkFg(?@Rf!aTC{1?h{kG}F%uILa|!gQ8@hiNH#^UZt4&eS)+H*sOuhL}?`9DH>Ywyv z_B&kzVcxB9zp$~{yYGR&scDC%`7K2yu^}wg#D;~>32g%sX7dEyaigYf`)&WasBQ6o z^)g^&)p1z&I^2JtDC2IScp}g0RPNv+(@gMbyaYI2-r1h85Z}YPQ;#0aX!m>LJY~a( ze|o9e?eCZPMW3FPg3Cokn*5vB;?<_vTRe7J=cCx#GV@S44~Q^Xr})2wWKfu3J4f@S z?+>1K&2czO%8>sm4RHe6w1oV(88gjOk`n*;!*(~|< z%vsk-G$=(kf#OI}%Cuv^>|Om%ZdBW+;;DMd(FJUbyWN$w3>hM z7^xF?w62w^KOlu0m5Cow`2h70P)U8zv=($u9b7gE!w`R8UxgKk!U~iB2-&^eww*b zQEzzM{=^3rU_Y;lWV|kH6god>Hg23U>)-EVA3wGlU3G15j~StaR~B*98*}M>zx?o_ zE01GynST#S0d(VR^;NnI*Ls4g-5Nauu0pKY8j@z4EQfkn+^;LFcvIO-yRvs&MFlVZT9`6_i*+ zYN{qAgnCF{Bx4rKKB_=F?Ra^nB}$}*REj?GG%ftj^%ymFY!-kXr&t?s@aDjA2=upl zJKOBNf~N1-%v@dPu-t>|*EhhyR2@3nhAE!&-V~YEHI)@;lQ@KQhz=2jCA`%6FWgBu zZ26lv(dKG#!0tv&vGKVuRwU&?h}cG+I{vahBaup2$5$xY=6xy~L$NfO?0)YuJMGAn z3f_fY*RHDQ&cvpf-W4?s4gK;Hn))g=rDKtTe=0qo;>j}~7z`c7)l?JZOF5&v#BGH2 z;K8h#o=ZJ8o$N56W2a7OBt!$<8Y{?Li$PCB7#>6xcq-;-=w$ML6awO;B>G|yfT^T# zA=+miG!M3kG`I+1lacx~kC1>_Mj+*6Dcs0TkA+8)OEvBraiUFN#tm1J}5F4@&|QAiz2n zpn!ekyiDe9MY%W4RZ|&qCv4k;HuyknY%sGTmc4_PE8&&<;5{0(67|8*bB!7(z)S+j zxCz*UOJ`KQVz!C6pNgDg%$WSrU*=-(L?zk;dQKdAWc4D?Q9cB=V|m{NdxMH54IEfU zkT+D}nzXLT5z7a_Mfrp3bc>-j(AD**x1f2!Oi$0Ae`OK@YgulyjQ}EIhMFJaNrN*# zzkfe~A^+`HGWUzaI8guPC=3q$fNsW_(4LxygC?v8$a!Z~!Nu+PcNFHy)JIC#*X z&>>_j2B}nxA?e@iso8(vyq$`2QM&YzLaDWBvk@^FmgzN#)FL3j$p2QmFSnGBX6q6j z4dR@rxVQ$)`SX6u&q$eZufu?$&D81jCC)aH07C7E zrv_-+I`nD@*#>3v5R=S9^diPK(p06^vSmF5TIn<(MG0|J!5v6xx6O}M9!MYUc!+dy z)KDN&FK_HgAshZ6i9={^h)EAmHU$A8fcdvh4Luimd(X!kokLg!Kp+iBa(wjTe=YIa z71<55mTD+Sn=%kNgg{z=2gwWtnRLZ3mb`ww5ukf2CMytue(Z{k@f|$+b8el++?R78 zeG;dyYOswA?~{oXqGBe8Lm<7``;78R^J=s5Jj^ZuAlaZtEPHS&B}L{}Zu<#TC3ET3 zH+4}D7LRHY61P{kqt*LAR;5oIPnuftQ~@%(!p=ICpY6dEXFr6I5O9^4U6N4O1Y5TT zIv_~T$Ba=n?xhctX?s~ER|^A#xHbKI3pH?D1*`6_x36DMc-OhJu5+iq|F*=mF7YV6JC(o2kkjDE-Iiv?TSq7LXWqG;#o5iu zYc=mFk9p?>aOu3|k7?5;!S>ft;ng(${N(xbx(aSTzIknvEHX&Wx^+m7rm&UN``+I! z9n-u;AKVTYby^=MQl~eQv=NoKfxG_2tc|ZO2o|9IsU3BGt)eXq*VqmF>7!{0ZYE-0 z(l;%Rze{es} zN`nnyHhZzEuA|*=MG!g_2p!(>h&I;=74@hH75lnGpkC0Z+8ffU$DlUX=hgC3Ui*>3 zNBX@2pAZb@M~#>Jkvk|X_Ak9NZd@&k$EOU;%$(xP5g_CzJaf7&l?_W;1{-&FP1S%= z8n|cUo#qHrr!d9tuYN0h63f|&10g;U(Rk+g$kB<;dlOR?=8t!Eb)}TJf=m*CqI5qc zo|}h913b0({gf}ZQHw_r4`2)0QLjh+~dR zb8=UHt(;0xo&T-3o?a~?J+{Wp`o|wUDA*wZ7v)w1dA%o2_~Df7W6;9xZ)Ls``Fv|U zIl?V0W>J(DF1H&xv_3!A`0cC@xj*eeDL`K) zjvICGX)sT+j(NjAu|j2qIUjNw6M29$Atmc|IMV+9oC@$u4DR019gr z6%{d(!)fr5`_wJdfR6!h^JX3xt=FMLJ&xH=b?bNewT}Tgzs^uyf@{n=`8Zr>FxRwV zMG{9GAZY}M3z-U7gyrDD^)7t~nZ0BC_5-8?jT<+f-@i)=+K{*MUpNGuzZiDvl#!k7 zait*KjKxdQTesqezrK~KN1g7bg_@BO5o_4w`SmZb@yZ&fd#nQPaaSnoMw{;KmMC2> zqk7CB=D)FK&u{Tst~CGx#m#Q9*57^=&DH*Fi_zXYC4Wn)pyy}djoO1&--2^ z*L(1wO&gcIAB5G7_`LHv4sa5HJt=;5dCjyco@^a1b3WLT!ji#_6lnH_s7H&-pt zfuFm@9Jwm7YAES5Oc_%3m-G7AGV;iHCM>8U3m5c3H})Q#FlEgmsB@^!)`Fo7{d7+MWOA}_=R6u69i0OO2`b8UrmI^v z;i+*#taIJGTNg|@+S#VoJeh4Pu`4N99_P4_7@7>DtAL8`h1(QCMwR4|x-~ibwDMjl z|5N27?oAS53PCtIxsI>eaQ~7E}f3 zlm=>Q_T^j89y^4#Sm6uxx9r_`7ncD;hsNG>8{zG3iUC-39Bs%gc}K8OJIa>MlFbhy zBT~l=iXxABB>w z?mJt}0tlIA`T6+{`OsuRpuZ=-JH%+h6kVZUIgY}2#jpQfbdO!5%t3;J!tIRHGznB1 z8X6`(vLuPRs?voT0k8Gy^Qe1=Y3%tG8fjV#4IRI;U*7%{zPtxzF@jxo*4{^f_`|inE+isNU zR4>2C%xlxfNrw(_LS5`pifURW?Hmvr7e^uyJJ2l$Hb=lPd~k+59PByn*yI|xzxd;4 zDz4f&;m*IW#paDIw?*}!;^#|igNe^1Si8uTo&e76y!*1BMJY-#V(8sAvAw>2ZB#Cq z6q-;IeeO;x z`#=3wY6`vrSKYc%^6$qR^OO6zL-T^dl9Fbv7YGE0&UyDwg|ImUG(9qwvT&+jfyeHI z1WYm^t%j>tqt?8FfJpKI=deF_wfT;;1lCu~gCweZpNOHufGX#oXU?9rwz7&CXd6K! zDlRX--)`rCe97DJv0Vp3LSNazf#2UN69(B>n|V>xOO{VstJta+unQWa^_e+;mzt`o zFV0Y$pUE-%3#Ku=5CR0MtBG{9F|lEq>z}M2?Lj6GQ=%|TL zOGEc;I6DwjQwn*ad3$$sqwr&YL{t4p^)lWPod&~V} zgKTZZ9Ha50qrJPuow1F;J#+(kR`OSq!vJ{FazPnuRCYKKfx9-qr=07U(MoIi|K5G1 z@xVE0sA$#>`Vx>^P!NC@Gh`MRr{WSY>3HTXS}OKgEcHW*%F{}5Oxh$f{kjS{Ql}0h zna3AQ|Gh)K>n~_6<#W$7@7C+@Y1I0!zb<8F9?GzdAOIFWd$x|uDuqv=5DCCArwKt! zCei>tFi5wZbJ)P@x3B+Y`!rX}@yN$)s7q>F`3}*KI~AhOQ=_P8%1sy@F`~bB|Eg~t zX~QSV!(?c&sR7pnpxL^HH;5*;9rO+Sn*?eFylhaKee>qc zXL@+l^wItn8y`LKYltYFNwE{t+T;2jR^7_sl%}C&C6mg`_SD+54^N~b|3V`gV7<+z82sQqsTAXR@ zDRquw$nfE_O%mwa(`G$I9Juvy{V_rk*=sFQUux~msb)|;h)s&wYI}7PVr4!Ib(=(A zn4?U9#tM8=E+G#uh~DBaH6YTE2^Uvs;rRm1pFzT13F;;s4I7Fl!UbK%hlB|h$SZ0| zI*brpo?c#_KbeEVl6ObqsPIK%&gM}l$mOL9z# zcPelR4~&)U=5@sRj~1XIg$dQcwdWz#2iDdaTL85aHq2~D@*s65&cJ@;euej+1FQ>b zM6q-?p(2_GN!d)-ZdWQ(7stmEHIXKlGV7zXz24rT@YkGIsx4Xs&{#4R$roAv4sYi? zdEs!6rKosLqvu8R4l#w5Y7@HS!9df?wr9w&C-%4_R&RK%;l-;WAwxcS;*S%{kFVUvqZ?Z)b; z)I=z}9_phQqEnDekUXJwc#vrL((d1H4KseiIN6?R7kOhk4`rUbbEbWh`M{WEalT82 zCaqbk7b^FI{@ABx2{rb;+eEAK-Qtde{B$fifH3%K{D>wl_fP*ZginWxjzZYz$W5{q z9{t{5+oRcjlA?2y{6=9oP~k9G#dTg@!FfRk;0PJQ^WK(h3mxf%}>+UCK$xfH8`rU!+cBnQ**KHu%tad%1ghoCo=VjxVZIz ztvh$t;}!)BvNZ+1&wqNco~aQv|ArPu1K`S!8=w4sr>?2m+e4MNpGwnF!=(RrouUD{lDuNdL&H~(HYs3X^~{@ zSmIj)SR{Ra!!S172MTV#SBPc4KY0#MrO@!Fw+(B096rW^mq?ofg!e!mN4M$MHP~)L z3!Zs5fd3XmmA?tW8RapO8DkOV%_)6Q8-9yYh;p}$CF9xTg#+xST;DgkIz)L5^*fDA2OnOqkFH z%+@9PV(3Wr8mgW&C|*IDxqYbv2x7h$FZLG-%3}HF;RVyLKR}d=5kd&OWhu`sqa-cR z4QXxp33DTgbpc$NusWEsT9P8Ny*~+tV<0PuH>SAt@_8h;!5Mzm=5QanH5wwlNKBcV zgEz-5=IjcIn|OQDj8c$hu<}ySW&!7`DKTta>aF;gJD7qYAi;KfFlRf>RShZAU~vb~ z0-0dDwY3mbGBOtP1^ryn3AWV%ERNR}PSK*U+-9{A+hv>V15_r(bez-LpAvJS z<#`C6yNnOy6I~K-{%b?!Eu(L-^$H?+5T@|rkM|APDY+!wLJh)}pD<2xC1_m%<7bPf z@w(hRJv)_eeL6CypFNa)28NKnGzVS%llON!)5NnHMaX-4&6>rdZnUEpaEjpX- zG@CdXt35z~cC-;(HsfqU)29k&0N`*ZVHK$$EndDPEVv@Cl z!SRuxF^Q=fhNP!-)}^66a!IsX`i#${ZQ}_hw?e6ru||-_qF#xhU!I1|OwXg|m3cei zYOD8|5kxbd5)!2={pHJ-lW|S+p|eNgAL(HUnP&IcC6JN|U(Cy{ zPW$nh?NLXewJPl?V2B&SWeY7{JAbAPdz%&>-hSi=qjg&h5|~k}dObT^O-swjdu3G~ zzH_1%qYuQDE7<{_aha?R_9PP|f4xx2XO}dk;2#7V!9rcblvPX)nuFiT+)z2TsZr#0 zk1&q#Y%Heff{HSPRd=9J%;`s3=(^ zLSbVd?@JTG*WExar>=b`=FBZYRE~k`sy!d=lwmGU<4jZG4iyRtl8}^b1_|PV1j6gG z@>)8YebFLR-d6K)MRY>{j-m7!u)U;?k`2dVE+JGfNMZ%`J&M2pq*n;Ahb-?)KyP)nLqd`UqCN~YwHIpeb5W! z&o7gTha*Z~G$aa3>Sok&D1vJ$XcM$Tun5~UzoOWR#+J6bx=&y4^J8^NmrkA5>Zp_+ z{Wfy+S%SX!bi=-35u^fjAXySVSsUpnfFK&6T6_M8#2gNH-7P^$_mvA|h`X{_j<4?- z-XqC?GlKdSF4oiOvF;X?M~@y+yDZpHz9N^Qr*d#H|86qJO=3~c{OE*)jbhgYgHqZ` z+fPT5A#y?-K$O%J(ZY?ayY!wJoHW&d5NK4N@b*p7x#F{u1}Q>!(TIIRc5L3Puu^42 z%O$g=Uc%$@IOI0ZF(E;rAcKc(k94{^?#^2n-O|MbSz%!Sh>lObT$8C7Y3b<)ovH|+ zGQ&=BiL!wlKMNQbn!6V1My$uL!i&GwF@{mv<0KtXT%uc*hPSz4qr*MSnqoFI`@?bN z^9U-_V+(`9*y!3PMz{LJ_%9n^RF-eO4jm4=e|h)h$y$1X;-aS)ur`9&5|c&Ea&z@B zy|BZzychA*&`n77Lvic*aQVlVYHuH%mwsy5Ocbkp%O%2}mv{2f zJD@iJalf5Ao%WmyB?c&@9d7)KM;m$!_9*)KA(;|bX*)^(5I{OAsEsaP$b>w8&VfuU z{%^Uy*Es2-R9qq%_i*jmz54*{@32MdGUnn|nN9?4c7KIZ1g#tS?dr;L)tKt-r}etf zZ%t{ggS#()6hyT!CBUREE=TS{5>~!CykC-aA6iJpCr9d_u++xA5q1{)!`? zOv+>BYW%NB6AgZ8`ShE5F!6I-Y)p(W2XFzJjn|^X?6JoH+uVQqYH96txfmZ4Lunr$ zAARHuTMdCG6K%%t{SJlX@TpTrEiEmQnv>b%lzZ5wO8<)+iky3c!P%p{NCv4B+f`mL zrRrYGxk6&(Vw%9T?<D@RxQ*x#NgCZ`A!$zQ*<%URKrf{Pb18KA);$xtx9T&3%HRJTRVGU0VFy z_F!(;Mhe0YxxD9zy<}tQd%p4UqQB%vZtpBSK$4+nZl0R|CB5CfJ9&9FY>ixKZmNLb z8AT^k=+{$R5~=os4`@Qc3_O!XJ)CGp9Pfo8KlfVR+18_zscni<{(0lZ_FltxIKif3 zUsp7}voa@)TwSK_76R+Pe#3@6vpc*w6bT%exJp-};>XN+sFG>)xsd<;P-p}q0th)g z&}Z)XcoAqC-yt_#K6@>FuTOSU0g`%SfB&`+Vx`9p9dhN|K_<5bY2?P$bN&TGvZLd4+m0h9Scm$PZ?qZ71 zLCn5P|Jk%v_u8DzS95Z9q@>q10*B-1_Y4~`Cids7nKLKT5F^%Udp^$f@SutuLPUNd zI&JU(WR*(r#f})D8^@qh-xV$--HZ9=u@}&zZ)kgqZB?D z`sYE9!)Ygfplo?UDDp1iI71WxazN3hkoL{mD2$1T;_U^+5Wq<;)2X1SCgXf7GA;HA z>d?Ce@5Y26dbymQUYouRk2~|L&lAnxw6m9t-TW%&5JBW4Qq{|g!KTv~HD7_~6==}( zY!&8W0FEWdE@@jB;JLlCfl5tcR@cdw6hhx}>UuY#1N4eyqgq;xVRgw#BBby@ISp3e zwe1%uT?uRky;&tp`I^10TlH0h-)`?-fJbZ%1vPqWudxdoY(JPJqA3{~i(b`s>|{Nj z4w;UB72qyuvFE2>LqAJ5w2zO^WKINh{nj*Z_~Q%7G34P2y=+B=OVXL^K6P%<$@*}H zKTcJX6T8bC+~_@@9VMc3@>!jHhZsCyN+_GRA3A4{gUpG%S-?-i^NIHA!N*qpTqce~ z)To=idut6qlOgE^6}_;LqJ+U?1Rk!Ez<27}E-ICASfqnnr7ga{zZ%Po>F27OfN59Y z5Pgq=p>`~*ogUjt2m-=tLyoR7X>T@+%8-R|iOlN$v`KBYo~PuS%EHGvb7a`#{Z|=` z`&&nD+vR+1KniStYJm7(qSPR8JuaKtqGijeq@-YsmoZ_?EBo0@c?1lNw0-T2DB>>r zv^kgSdGaC6KJ!@rlH^4G;=FXj`-5|X(&}RS=mL&C6+jb7XML>4ZtcPugoAu-+Q&pU zCqQNDLE{KcR$`4Ib*;>z(>tq#e1<$vO~0Y3xK&Uvh=h3Cn}dDTt}~vH8p`X$+{Ow? zn&}1kiVfi?7ndS~shejbqkMwYN_3*MO%%;;=K8Ha3r1%831atyNdt{Mlw z5c)K!QTNP#@${)b+FpRxAr_hPo1MW**je&UAWXdXgjk)J&TRqgBlT@93Lt9k>8@KJ zkn*Ino79>&Ux)6B6m1e}SmmD@F9#^yui-Ru^WwV9vh%OGk2&C4S`Q7rQ^EDWO1GCP z$|-9~u{|5DPDqy+kzFbd0cF9^I#Q1QOJ$l1FJ!Um$6qv(4t{)L<@Dc_%a(Cr^*zB^ zL(9rMP$l#%`WK2Bu+L$gX_xaK)j5^t(>fF17f`!ETIQ>gZ z3~dUsH>aR`KaUB>+OVDr#@bQRaF9-aWbO&szpL=*Y`Ot@xD(^=PaDtO@CH5Ztn~DK zvAj?+#jl`H!uz;C+5Ebrp`n0;GS6hbsAhZjcH;yX@o$r;ZxpFbq}FG+@;dQV1&&xp zG5x=9iQ-!*-W0xgSexA|z)(GIH-%30sMVNFINmfX#Hd>`9Xy0nM`T5Wy8V{MV!B-M zZ=ZLPqX|Sh&DH7f7GM|@VUqas4JfD5mcKh+Z_5z<^4rx%MOprICFiTixxZmhQL_l& z7j8LR)2MOd{?7l9BN!Lt>=dq?@pf~P=EpoClw6`ySVm*fL#g}s-zu^aNX4hSx&%`G z86jNPqBNEXpAtw&&eG`iEr_mO5vFn69El**(oCn*%og$|i8d|&7_(ZF!4~qqkPgne zK0Ae$qh`ECb)3C43Ls6%c(&l@a zV%+E4!j>kS#|ZjL06|5h1w`1CWB1&LfBT$X^vWUZexX6fj`d;02Y^IWT<>($QeVA< zY!EnqFqCRbP);q`Tclyf}FA!liQ^F zpmU9^O%K!pa8n%0r@Lw^uVqVKs^d5riisNS0LCcSQpl*%*zpI=b^CPg+=z2)5UJUo zcbn#Oq!C8kfKGPxU%hHi=)k=qJmf$P)9XfMa546Z;4rg8_Vb~8qa}%rnwqdzp!|sS`KLZaZ(=1goFw{ z`Gy-6lWkFc#~l}X8fcVC&^hi!dj`5Uz!pW2QS=tGK2*jmG&D9AlRiFh4Zwr&5QNQ9 zw0I)$rS}X?Y9mr{wvlMz5RQ16k8cnDEgav75d(?0q9VcM0R)d#BOICJzLY&UAk+qS zgFHRu+*kQ5ZM3Yy8hDDBn{I?U!U9X1qu2PP?XOsD4l8>B3hN1OP8zoOUYDn^6{3G) z-*%gl9%R;blleuCP>~3dm6dMRhm)dHc<}V;?G={9QR;fpvyl#vMYv6#tblHm8guN} zmX|&>K8iH0hDFn+oeT{X7EOb|AUB7F1+o}~MeWk1DeVnHTJkvxQS0(y^A;~|5jY4+ zjDLV?ifi;ptNMt&_ez;ebQUa~X;mVG2uaEL_ul}*6b>uhkO9PIfmYaDT=nyyk+W_y zgW;A4GZChJtr2$6$<;N4wS#mtXvTR|b-``gSQwaz}T(9 zf^HQx=HiB)7k+*7q+}>Y@0`_P|BBnjQ@8%Ghdsw#m6W|JZRNjPfNb)fU46XtLddQB zeB>Y9C6Xk3=Intr-Qm%hbCKOe{ktcr?3gs^sxP>64V|@6Y`~vb9 z?!)KX$5_Xys6p!zIWnaAG5^DD^tN}A=!1Am>)5IPBO6L(mLQiVaz3!Qdj*UxrEcN8 z4|SZ{N>ekE4|$WS(Lf>Wrpz80@-TJiSmJ6&VrBM-BFOSyDkEn+k*5TnAE1|8FTPHYMyo5S4hjT8Vt zLxv6W_fojI+I&kEs-jP{q3^FIl+IGxtV#JL>=@1uGcS z6^5cn(kGG`BFZ3AS;TPn&)2P9nz~zuhcy&uNreKaImhGi?Pd{_iV}2o`xBp6E)=&@ zI=N*gi)w8v1Mfe|k`G+7XfN0pGBz}+hylm#AoD>S9X7ps_ihu%mkzqpvVJb|^cW4V zSoQ5y2k7?U2B!b_L+UDc<5Un)y!C|(L4xSlap&;jWp%$d^K>Rfz(!1K$i5qsGVlFA z@*(eQN^J|QW{!uamluA~=UW)9yPcbRnM!|pibh-}ysr#y6pkM>XU8m~->c2>qH(JN zYQ_l8R}n!vEgw6!utg5UZkKg1X%|d`ODM9VqCeFfoMl^gf8;0nR{4%}M?|bpka_yeL zqz^8J10nuAoy_DSr0e;S^MC&QiB5bYXHSbycfuj0g_xHERSM$Ix4ZuNh}L{WF0zO4 za7`G##|fY5TM*5$K6-=kR0ILDa5S8YrkicpVIcVB}>;O~P5j4ni7k|fH zNf!!}{J=B!G}#Aly*9w(_&mGuAcJXOJ5sK#KpY2wSK80)_o{f4z=xm!6D47LfxnD@bEaKtnug7ux#wPA)S{ojnd;+nS1;N2fAz z0c0T=O>7X26clJ4FtCd#k>Fh$A#@eO2#wouGA^YMtr`N+)je}qzr5zO44Tyy6=1+= z+1c^eKC{gz*{mELHPCK9iag$7M7T643ai2Zf`KcO+mk#?E-6++Vsu2VF@@BC10&3P zR$eALxKZ}@Yd{c*x>Eiq%3RIIQJQzS+KluuKR@w~6F2z#$3UEb73x;wN+)v~R`Wk) z{@h))z>Vu*;>^Q@88D0YOPfU~q?L_=PKmq2lUCh)v@&bVn5xx^)vli}OxV&o$QU;N?ILdr){&;cN$6mkQvB^*9nkN7WAch1f3 zyBqO8?C?C^mt*6WhHQa9qWNv#LwWFSF(2aJ9Y4z610oLzAGX9Sj99RvjN#X5l$hA1ticfo z)B`537IaZ{C&tA2O{({YmusL`fx>sV!CFVdfy}hak!OF#bo$QKC;X%RV@-TaLx0VC%# zElI(oWOA1SFoZAjVz&j&sMeexOt9|hNtU{0=gvdpHa)Rodm_H~6Trx)WL--a)5W|C zvPl_4Audm2lG9IM-64Hx?1isSx7l?i4<3|c{PGtplz2pus_S*@W?vb;Z(kEDRbh1a z=7HNHB64q4cvE6#^jl|^$adqQtRFOX*|OBq?=;_Kyl%^I4my>tfa24L;V*J820I%x zQLe7wNG_9=Bh#cg%=>*bQvY4f9HYn5X;Xi+tD>DVG>pqnPS*{~K2H1g><6dS>?|s4 z|N5}Mia{2mUXSx~;BG_$g(@(k1(WW{h6N`^vccgzkmHd_OAW}@Ge%z>(wDkS%-6`v zGs-!lf%j`E;93LDo;^DSNY|HQ=4!0+xP3XlFk+9X&>Zx$t_N8ZY@?|+J|PP?(?bdW z?6j#ZP3J(uoKNB|n0TbaAxQmFI%}!*e$*h(m(y2kRbMemBMe9#!L3Un4B2uEw;p`Y z#4~gKSgvn~zWQ;!J5|}&u3g5zQ1GRJQ;kseDO*LPGmQNQP|N|T*4s$=1pCf0UzGG5 zvPEXyU{n`M-PS*^8<>wNgU;52M>(xNeIzz^4F-79qkoRXGBGaSNgzDNZd`_*7KN-R zL~7M-q}r!IPnH?on>M)z#DgCxzF?XnBjcQg?SULxd)Gd;4m`9*QUq~vo(S%D?nDS% z6Cg+kM5DK9ZzYamWND`5P6?mMYif6LN|0JiSVthY$)t2B zBQ^TCY~Un%Lf{jpB$2(6Fn&*L z6l4V=>2AG5c`SV##dEByIOxz(>@KNx1N%LP?8zK$*H?h3lw~WdRAug^0HN4AJI9wN zk3m7Jged5yzJlagCPNBNe05s)<57J#BPoPNkY;9lFB((b%F|;v)*^%-aUL+@I!7}d z40II>#it}W#dHI!ALBM7l-KknuVjxY#WhCIJ4@9rG@Xi1ynH4v&2ei9L%oEJ-LiZ4 ze|P(TGY4_tdyFJ_8R7lT_ddz!xK)cj9HYavU7Yecc%jE=4n5_-hDBC7$3jC9|CuoLyb zG2H5Cu__@Y;{o-!h0mY;!rUh%K;L2fs93`vz^u>Y^GwK&CS5!579Sl9r)5p)M3(>&3^^- zkdZLdP4=Lrzh9QR6$^-Dz*2XM4#T3Ivz9JfrfX<8YWtR5!f(tt&c#^gya^5pd996oeMK1)A`Z?W4m%=X0yy=U?~RZZsB_n ziaMQa!%vvdJuG9#p8)Q>ynm_-|2i_iR(?f@QjT#^Byznpwh8TjtpD+}9MZ3k-)VxCvGf#!cT#@^=M-@~2^5xfC zSt92X1R3+^>nF(AF4N^J=Ch3Vj60F4HNwGxp~pCo%_n1*VoSVcI5N^h2YWe=C-c07 zCaJ4;nWK1M!ELnYQ=Kfus?A+{rT>OyHKp-!kM}>c;$fF?|LGeuqv^E35#6S+CRv_p zpI+uFo7OSUSjz+=Xh9KCK-DaN>P#7Pc-%QB-7UrBVY~49M-l7h?taLp%x>8-^P074 z!G1LY=|1=VdZ*3V&qB&bMoSV;J;FYwujJww-h)YY`uQQgtXsnd4aBnq)E?)AdK41u zH6HER7rTJ6cbUvmr@-C*`SF>Rs9+Sn5DC#gf&5gT6`7Gq`x65RW->$-9|HPU-bZwg z&4w?nM27o>4ux}b7b{=&vPLTU6y_=le-uoPH`L$Dr|rOqeg9}$DuR&?E3OG`s%?I zm~@%;K7_i776St$$n~+OZD9iP3Rx@}haZ4DZZ64#3TI+lAp%{SGby;jffcA7bcmJ5 zfNI@=r#=8kP+|;^b#Sj$KYWssVs9hhs)GVWrtC#NuO@FlO-UN0DlHgRlt-eMObU%Z zdbH)V?z_chWyg#%#+OQeW$d{*gHJ-1UA}kE`SoAx0|pEk5_EeN3=GdvTl>h#$Coc# zflCG6z7RHX*-*u;n20Uhsdx%faT>NosInW|IuyjizSDkIhZz83VI*gOi95=KZG|PM z(9{(wEacHeh!Hw2dUbmsAl#hyr@z~0ENyV5|HUN=f8+=q-(2LNQdlw$&yIU4!eV0` z%}&8uYnAy|UeGD48ZbOElTMm}z5lV%T?1ysp+9Edt4USgT8bw4L8`ayv*bSEq9U{Jl@Ar@rYw^argx){Tf_sL z_G6d62_0k{hAhhF^`E{GY#nsXcrDQXqrKOS~7F`51TM~%s3VSjh&k_9!{SON8y$uE5;e zAI^=&zi>&?v11Aa2T+RPRL`N&4xqtN%;?H%qde#j_M2Vs<06t}45Je6ZKy+Esq`hhkcKai<^f@2`ZVX?AM$)I>k0Hu~(YO zI6VbV>xxs=j_GqkL^67+6-YvTFbtXQNF_gT*yl~)g;((Q&udiu94GP|`?FURmK?%K zp+a2aq$5s5J7&mSPf+T%PaY0q#3bf-y;m_L^?20DA|xk5u8N%jx(b{5^Sg=lA8h9o zyqoAQNW4B{0{pQi5T2x)B~u`nl;B~(bv8A8CByC*fi)nOIA>6lcFlJ z3d6GI8X79(|LSeDwCeCiE<-qRf*qWP#5g%*_x}A|&}v%Jz@dtkqz+SrH)@&=!$jxh z%B&T)E>4-a^w|!B{RJOmj=o{;mB!;G95@t?8|4hWjN}N9ik*`kWouqtV;JsmiDuX^mK1~uc7U=^;mC6jwP^G9s+dwt;rK%UmT=d;$OMffQt&pt<|zPXGMd?0 zv|C)=e(Rw3sIGTCTpL;#X}o^+tPT`sa>97MEklGXnL@q`P!xW>e2E4UHB31N(dB?{ zC*tGPnd&!@TT8e-KK0}*($`(M!7C@UfrZY_QxXl{irEDZ#8m_PyE&idBLyduJnB-A zSi_e(KaIb@>|>ov*%A%Wg7cq*lh}OSS;-X5%VMK$-Xa$6bN?3n!f>|dD z08*5+xfg#10Oz~m0yJgtpFAulybu0xt+^zlaBn6=#;3T4@N7h&BqDs)qerW#DCxxk zo5*F_u_Rm6%$BaMd+#1M-_8eG8Eh-T%}u7_Ex1`{OMCTewN6oDSQJ%ky2bU0{7%r# z>TLdh-|Wvfi=U7J2qMZR zmpN`xnW8qcQUxhrD-<*fP;P5>(e7CY(kwbd%At7FT1}%lz*q zoLLLpuQ>T~?OBns7L&Lb=Hyw@S4v#UB=N@5JAP+3bM;^wX;zd9ANsL^HV2LyMD3jy zo0J`pZH>v+WdL+(-~!H&A{bG1kXDE?B5HRt^L#5PCF=yyT*SSs#btT*S&JTLn>SF1 z$3KNI?8zXnsf$bqMpq#6)o4xydV~9y6ZHzaIX!fc77FRQ^osQ*St|h!kj`+KFoGB2 zpYO7{;-2G5Mn)d%vM7P6eJ*=U8z*^6FFM#&a>yMung!c|yx`H)_uu{fo6;dCtzk&T zo`#zpY(ch@Nw+XLa1h$#V&>0DLyTl|j~8mSRj!t@zj$sNfUIF1l;6>ms!%5^d(1y& zs~Hs65Zjc0kJ$h5*Af|mxP zI#d|~yn<|?6JM)(T>}C;KJA*ibY1e1IsG2-)=Ag}TZ{`>R22hA2f;>xO}K879AaHH zdeWp#qiG2}~sz%#x>#sjwfaDNcQ0=`V}Lp5n( zxCBHbeH@g~xUh@!8i}%WT2QohUOZu$3Z#pm6-;`V4~UCarx*?Z7y>G6w8>Mh*$r{V z;t9X&n`6#*YBM#2Bd(OZ)yRAm<$>fBG&)C?P74{qTjAQ$z(6CIO7*!iW+~~6sB^fP zVsdEo2O{)U9H81=|2%|M#60!-)DANd;Qo{Py(UQxaP-=0gZ<{9(+a>5OS;~<(CNn^|k4Ckatmb}ODpM>LV1R#!LRJ~~g_`H7F z$rFiGFi7(0Y9uK+E{3!N$Pe$mkt|g=;DBw&oqFHox64g z(K)P;!GP@QKo0#*njYtN{5}Pnn|X$d{h+X3;v;})@X_lhVCl3U-6?&t#}mbXOb&;T zQ;@4BZyFpo*2QH#S#@-#6$5i9ChW(LZ>ZROZ5naNmr@q!O=AzHYBYvOC*gbNlZ_Xg zX+!^r4FrvnsG%C>|7l1|^f}58a)e0t9e4frh37^d%4MW)z;%i1mss(mv+{Wo(ldPJ z3NJ4s3g2UBk08eF8rR=321bhX=jFYm4xisXa^TsopkfFCffbGUxpNa{VQRT9vg5)f zS_%pqCK|UmbEMZFEkJJ}%c$g9x85@-#1M#r$91yoTeUbQcuh|Da`~OLYpplzQ>mk1 z7}OP(CLUEyNiUlp_AH`1$B$ftM1Rex^v&v4s@vV8AM_nP&^S!2z@fc{HP$#YK`t-D z#hCg9OQkV!a(%FP(JLG0?CS%!Md904fiOkEUjU;6QeL8+jZ8~4L5_xqtX4(swrqT~ z`|j6UevVX9G-}FgLo1a@29GxLZsZeOcZC`S+>r{_aAe_07Jo*RKX!waLo)vuwdCJc z?PEFq89zvrY|&pWuB3jy)m1-Ft>5-=4;8X>3!z381G-JKtB(?0T?Z`^1~<+R)!H>6 zQ;d!XTH2=HigD{=wL8-UD9E1JQ_@Z~*t}XPrKXmwy~p&6cpoZej!6>pYf|Y(bS8{x zULLW6=67kd1SuVF(W83(1O=sEcF*ZchG7L#3OScyDn&FLF}P%G*L!PG5(y_SItWCAY1()?t6p&T4!lDCq4bz6g4L4a_t= zSA3cHce45@6`br(>}-Yeso9(dLBf`yW@~BM@b|ZwhUA3Tqt%Ia9HF1bPq0S(r#EP$ z>L;g|x&ms-kN`?L8TQ-kH{PhG_HZ4)C5{`^`4FDBaQ9KYRtsAW+b$rRO0;{7nJV-o^<)QG)0s{emX%~ztt^4 zBx|)ky}Ek=Sd>pRQcoS+G8VCIxwr@Rl-(GV&WL9?)d^kuB!UEgzh~p%uxR}G*s{NM^6`+$=5;aMDPR%D<1K4n``m} zkY#dm$Xj&AwmS z2uAV$zpoeH=N~XIfK&N?^>2Yz(-rW{snDSw$C31~ORt5{yg~v}1h(k&$BQVC4Qnm- zsQ-_yGmq;zZ~y%_YqEt(mJr6i6v|RrvXotfRJJ0N?4u-#icylr*op`d5}`$!GasD~yaX-%QzGsr}_w#u#*Y(=224hAumiW8_1CYf2CR%gzy;HU@ zYR(T!jHs_UBgZ>CU(fLWz1c@J*!3i9_Id+%San(xk&O`0cOkqAxq6<=9pGbd#+&b* zu?795j#G&>B}rpET|JPj*5_J_u=Q^*Vw}sDXO>(3x&Z2QsR+h9XhC{;aL@LT;TjyS zw^O&`6s4(ANPmqd<# z=le+V$HhY|hb|A90PsTKe&RG=K@j=5nX_!<6%t{ml}^B14acb%|Ca8`1CqwrYu>gF!)?%&x(X#FN7 zA4a4+A(1E3JD}~%vuYS|d;{8Z%YtsqeY7f3}!^a#f5Q_ za0@7GZ>{t5Nu#9F=|c&I7-a{(X-bD#sfU=^snLFGf2x#46gj_Kilj>$pDpHppRLXU z@uQ7EW8d{y@Gy=nXu6Eh!{Sj0DXpxiSR*wEKydMk0f(nF0+ALWHu*`g#g`%@z2Ks# zd{QGF=3=th<-Frp)o&)>Mk0U^6mW|OPkbT#;6MM!F2+qCHecUB-U1|k9#BXkjfCjM zi96+cOqI5gMaSeDwW)_i+LGS01`8MjSZi_(Y_3gweY_{Be zz5z=y=RM#V$Scmd9&B-D5=)DZ$;4bw1^}Me^$gM;wfp)5?dq2J*=B)yEqepF@H6jn zq6gFVna{i;VZzuA`Hiz@PH%=EHc`?)DOVT>pp5g#e&>n-X)j(Bpm7)K37cMlo~~{y z`Vhs>!xvJ^f`689Qm^`CKWDbdYzvFfEGE>fDsI~`-_tV-ayiCp<~UnB-aXRBjV(~_LO1yG|Hx?rZcigpWXj6 zQ`#!{Wp%4F(~jQXBNE4P;~cp>lXaZS7D-EnNrHo&7s;>(v>n6{s+8^@mFZ=h` z5t>PAx@0~jCiV?*l_*{X%CTmeItu=Xz=0g;ZHN7;a~jeXPp6=%u%+I`PmNLLlu=TPflBBGaUdTg-29MvZ|wNU>{NSNj2DR8>*RJb5ysBlCb5 z!!m{r77al?Bu=6ZBD0!zsbJt0~$UZ1;q*b9mv2PzIL*hVOv5+^=8D)LU|>iU^3#oev53yQ!O&TEG*q^3_(;wJeQXTfEIh+>{ik`!ZJXX9Y3FY!+8IA3+ z@9ff>d?ZOv&j7K3i3eP)4^srpCbrl*I5y#rnIRHeJY=e-@Kf)o;+nAm*A|C&uq7Ickko9k)9&gu@8FuW_7-6MmNNEi_{olxb#wGLk# zP1xUp3W;ildtD-Lksl>saVr0KB_$5fef+X9pWp32cu;f)0+LFt#O25&+GcWHah@b5 zde*%xqaN31+7A{BD|ZoK-<)~LqEEqB!RU;c^OB<;5qB(FDEM~C!PJHcpu{9bw5b#_ z+`L0$?C7--nYREqk+}t=FF@5d=U|a1i}~y*%zqW^mz>a&BO+u5I$uZ(nVG>oB?;#o z4ypz{>JH1u*2`WDc_vXeFp%xJ(E9wC@mXS=c-vTj`G{Y|4MT2*me^~=dxjk4o>-ae z(?V+ogt5_Qhmjv7{5(v!F4YUILVX%$KOH0g>y(0*fP_SH2&FA4WJG;|argb7yhrJA z*oxCIg-nW5MZMXpUqADCFC|%uxd|d=K`es6&z6lYViBIE$m@1@7}|oj%#as-=1A|R zEQzn74yr>r4GhG=U~zk^kwnBJ8M$mWR%;KY4{_OY{(OYjL@O>1OQ1sb*?^6PzreK~ z@==)l!(CEeAtVM@+}W^=q}>be$PyX9R4@Aq$c>a|5&;4=jySWatT{@HY8He@qr@_p zbA9cTCyR3Z-%aDtjl(fm#)XbZEYF(xO(6ilS)p4@j+}Fpuv=gt6AL#Q>pNH;2P?u`Kifz={Yj6I;9Yu5q9W38EgN_(&KKC43y)?6*BQ5EKKcplcNVNq9KPb zs#mOE$1ALYWk3Q0X@zhxTk-PiJ6>(P)N3&2GTy-^(G1G_&WZ6ptcC{Exl~pX3@;;M z5a$aFH?~f?)a&Jm^{5)-e@a38Jd8M7_Mw7OiuG_DvR@g`AeWok^t+Y>qS5Y%SAxLZ z@uW0d*j&WGuWd-IF*tBcs+DHK*A_U_40ANvR=j>FSPrXR0^GU%L@!QT$AgqqB*|Hc zwtn@|VGd)xxOD{b7W)@09{bq~+rg0G2A{^HSC2_AD5;Ez>7Dww!$0)wLV|I}y9>q6;WT6FOG2O+RR9CJ3>J<9haj zm|F-OG$8#wIr)9G#!uY1F)9xrnlq{iP&~2DyJU2SK8VY5g?@6V%=DswjWRjtZ{KBiZ^wNe=pu*Q$+(bn&OKzX7oDriWeGuet-Bw*-lc;>?^W zO;LFLdJ4oN+7#wN7W7C7)=RH0sl@fZ{EHr$)?u{5e~5qvCP0I8*y~J?%cSC4$=`;1 ze?sD{29)o~p%Zbkj)6>_pAohqnC4yunez6)z`%bUlHRNXX&+ZdTRU89i>!A$@ddb4 z;`f|b@=IAlN9+6ZBaT7GwO0sT9Roo(<75?~)BBR`UkrJj&2-?WKXC%eC`@?)ut#b& z9on}N&c4*?&p%Hnu)8SC09~L`atE# z3}4cut`@uvV!3IL-7&=A7?b9oZe^RvjY~yWO;BTdt)W2jA*GHhR|e$dhD>gYh|Fk1 zP$SI3ldfs%2{k~!g}F5MT}SgRzNO*0IS!xGW=-$CC6|szG2=$3bN>w=sUitQBgjJP*MzWTT%jmLIuqI?wGf@_5SP`HE1<=jDi$qW`sL2Ya~k~m zy5{O;g$kXB*}{b_$Ed2+x;EXeIQ}iYdO>=@g0wBZ0hQ}lHf6mxqVb8a{eSiVC+ry2 z1~d>|3=OUO+lok#EGexD{f6vK_IV!Xzm196AUy60iFY|Uii58+vz$Y#U(v_HM3}ow zr=X>0OnqlTbr5fxM=vkMZTz#pXk!0)<-kKuYw(_MEMbj9T%9`4LP=TRPwSAXI)zHtOqBGaJDjkkLdb+k*JCOv?d~){*S9K9!3I}N!g>p zDZOr8gqTOgM77&U=s)OA`i;JCtp2~smpR8w#xpenJ*RX8;+uvU6qF8sJi3MzpMMrv z7uL-8*=$y&=aRwB7s{CalR{|r$6j?CWy8=`ZHKO^66u9=*GHVPX@dkvYRJu{UuAyE zM4R{}8OqD~)s2nhqh&&_{X)bz+vE#lDt1q!svHLja|_WG`bx zZbi}GP=SCE;UMAHs&MK9Z+^{k*zV)w1I5q<+GnEkf5m6KsD#5)qkHz~p@N!eJ16K9 zw)tY<RRt+&Hq1|n~|UOl9H0zNF+`$70Px>GoY5D3j_%-8ug7_kZ**#?ndfv$T2R3GeR%(1-CDt8I1#)mVU{W1GLU5(b_EL zD`tVb$n*vG;CdxecbC?$teAj1*~cv<1&N~H9iauoiNg=*!XQZa2ca@8fmY@uX*$m1 zdDX$Z49jK!U_Vfk`+LTv4S;$RM=y0!3t0Yy3C-(D*A5V1eI;U?9rat7^8E6u<_giZ zQBc0$>yTcT%q89yarW?Z(NxvvhM*KoTZNB@D_jeieK!Wu`%=w$|3nsyHj6$K~g0822dO?i5WyntyR%`o}=%$uAA~s@5!!T zoKGYQ&~Q6VqBSI89}kwyD*X5>VCyqdpQ~KjjYQzj!3eE-{?nXZibFEy^3OjFUf@#5gDgcU8(PXXGmmF9xBPQWT=Oi4^&_`#`K znE*c`tQJd_%oUTF4dN&h`_}Sb1y?iI_U3(mkX9crArdlx56L+F6fs7zmI;0O_ZLtP z-Iuy+#lxN`ii}2V{XR@KHzid8&4g(AMaOmmn9Ihb+sqhf#X9K(EdV#1WY9=SFOp}L zPy8N}aZ_O+$FKtwGQk9yv%(#)is{q(-(ojQM*PHy59=p_3+?dtPu-Gxl4&>`5+PgY zmAtbpX+M+{XcDPYx8@z?zf+nQhEHdQ{Zu2dh#!)PHhfXbK0>Vnas>YoRH4;AI!iDB%&CjLX**huZ$&>20;p@SV^N#72qI^=k zX*ZAKaXdkoKF6jqfZ}hBLm9eG08LtDj)uW&tjWiT2i$39I_ztKu+G{;~ z^2mPq6un37?KNv2C(K34iQ!VhW*Ng$qkp-5z;GawnP<(<`aiq$aLFL(4H8g#M{%7= zRBWo=AB<{jnGt5DgrthW7FahLq7rL_(d_h#ayd2VCOgm-j^{ppJ^~XzUlF1~0(>aT zcUTX=Fco-W?O^(R!MnBgg-!(hs1xphcB`v5gi{gwASxK5p$ke!8NGlU5VZh>AmEr7 zMMUR3WO0D~qnxRf5A;aBBlCE}GUMUDJ0!WC`@Dby?eQa5&-MWZn8hYdy}ILK2fL9k zUoP)UcpG9t7-K?bK27+L4wutgZ*}_xgaR}}zaSBk@CyjEVUmf}h_Bya2|MO}f}O7l z;{C?dm4`-dxnc9NJwaZPzH{f#Z%!M@EnkQ>YG(E@zd)&C3Qf}Q{!a^ldr`16QmM(X zWU0#T<_j*SPX+p%`5|S`yR9$|Ymu?i7I!r??1*;RoqkemeFDY-@_f%T{e|S7D@eVkV>za#_1?NK`1-)CQJGs3pNjuwyJd6&X-hLXa<<~{oyU~JKSHeoZU!i1@ zaVNBiD<=3uSCJO-Py1n#MZy;U_yG+Ea3n&Az6F`BTcsB6PHwMGlG@;(%yRDrDh0@d zxPKTt>GKgqlH)2`49)<~&KVyp{LWK4z)Ca|)RMuxYXFYmD(~WvqPLQy9PVq;u52`S zX||sv1YiLGg$cNj1u|w|jP0{ua;m8r1T6}3dEYy}zuGv*`M`}5tji1o_$F?dzFUqS zITE%Z23orlrMLK^9UU(?-`aeP)(I)wIK#m%IkTysn2U_sSuifwEmg7TvX3JfUwZ`2 z_V@MgNoGKC6jI7;@nIfJv9$E$>jK`ykx{|e6K`=ea$MUB(~oY821dYuY3Z}KL8h=8 zsFOQ#IRlg^DG+AM9N-nU^>+rG4AyPap~LwMh!^~vjbVy@!_7PefQ_p9=|Npui>OTA zBN#oUP48Q$&z$Ld!N7(~n7Ukk8yr6Mj8>kqV*Vytu zDKZ6j15?Guu2lW@;XGC?Q!!_*1k9Oxv*N7fxN#c>u6z+HGc=_U;tVSQh{3d&NE`lq zG*>^@YKSC>Xm-rTm&|#7g=vM8S^B(7s z1Q8nqkgt{vfiHS)mc7Ic+JDc?&i2s?4E5)k3!p9HZ^6&t zqRwhRyW~EA!_ms>{2{M>++Cq}5BvKEFE2tb(`)O__FIp^hhXB1^YY*I*N9>I4(0?E zHH4<09vD+P0(7V^M|!o+BRhC@P9?{R#JOX>?d;e8zpiY0 zQrhyydB>~_+y6A$SXGplcW2(was5T9iwG&+&7>qp9+TgeYb?O;PN(uCsSuC&PZ*ar z=F+^AU8yU_0-kL}PR|s+LSB#9Kx(eDc!d!b{EQOw>=r}&FjR0h`(dXU8!O z8xBaS`r(r7uw$^(x17UcqH~8=b!;=DxOf6rnCKwcm?bUWQP-8Mt?c}iy<%;4I(p}G zwvuFHwcqgfhQ1W7uE0|*8>)F)=;!;FkW2JP6jucx*6^7*s#v}vZfPjQv- zyYMP$4V(4K#|lg^yDlmaW6yqGD<7OX{GT4TbUb0&!!@V)q=eT4m3*83NH z`$pitRTmND0wNG>I1XY^&MANzAyP9l4;yUbWW2{XgU~ysrUPZTp1NJ&>g2)?nV4s} z?S4~~0G7_vCi8lYLM@(+p~lqK@DXo1mKX9@n!+%Cx~$uW%^<>AHuK_#fBzwG_#2gs znCB_1cx`GL8tc4vHg4KF*>CBfcKjBrmj@^>=UykAP|{bB06NJ`O}=+Q?BN|dCY&$q zibgQ1R|Cqv-j7tCg#`zXS)BC>9++b`^7=&zaa5B|3rW*dUm~GIMk7H2{))HpGCn}U zGdH}|Re1EfEbi0wdKk^5t_9ZOy4Z#nT%zz|V>_W{k*)&)mVhLbQJx9^c0JYd?@1xn z7jGc*7Htc^6v=}y`}xJiO(5p57ME%5S7o`(h&Ww;I1|sw50Z)JGKd`5RCF5iqiP}h z7NN7_JY)Lsii4jHZWu^OWj%0TejnFKl}*cz~N7ZtERc;S}W{h(^FIPRi?JoI1;cKr$E>CivmB} zLoQ2QAVLK#Enn^cxxl#g=@F4*c12rSy=S6w@eY=rq$BVUglZi>UdG2jfr$WJBz^?T zrnc4eRDGH(Uybk5%&8;?NUZ^wdJ8m>#PT|2{>0EHs^=go^w5@^X5xtDM?^bD_-*8JhATJe#?MCJquScj5HCM44t zFxf$wx2Ei69NVq6vCCn~R|Zyegi^l;g48g0hB9VeL7$MQe=cpI?OEpOt*6xsGLE}e z-X2;`;Xhaof{)J+kTFmqWf65dWd8BVRa1EYTUhNfRzjLDkY$jbyIdN&jDZL2@@~|i z>~Q?<;%P91Zm9~T%<+WmicD*NJcz~tN?`Va@-VSPgUa^uv0GLL?EH#4xv=R z@cdZq1s~w1lM_na-X$87bs@a-PCyb)Ya~_gDxy|}k^9BIkcmIJW+QxMB2&M4qBkrg zVW4iV5q>Knc)&=|@@nL^YNCBA<@oJ-27Bp+Ir8EBn<^;IM+}S?ZAM2!XQ4So7!c!H z%V+CUDjYb0@z^7p^6W9{=CQkoDLC2g$cVkPiozf}AvR?Ix~8qnXb|})5p*B{W)}li zdF$?=p`O$Dd1=Y9$TJdsh4cmwX}fB|ErgUIX+sVnP{B6_owPkayO@U+FQT{3^VS0y zFeSzwZ1dn-fpPFn%V@JaXn^^#ZpO;m{ofQ7*?^%4_#zWbzz*e=@?Xb$$3_L@Jbms$a!u#Bpa0ea%-lo}d!exlP5W98!Ktm(Tl#RF!8 z6HF#B0bq;Xb>O_9%_YOddJd5z_1wUA%G#daW%h#PF>tX+w3v_tAm^@$T@CG5u6%7! zPumgd_Wpd8ND1U&Dzp4yE}Ps`R^!|gHd7mS;BH0+MJB9*GnA=dyADnc4%i|?=lSNC z=DAcKTeaY`C2=y!K81Jgrmd~Sgm_mI`)kx+^gW~dX^aILMY1B3*s$R@+%{UVZL~Ym zPaC`_IVmj{XsiSD3V(U$&hhxKAv1d~0GO4*4IIjZI*bEmgCA8tfDhrG3|t!H(MTrr z0&wxl@6o1QFGxgwz^`@ZZbIX7IJ@+jwatqI*5pRL{i?01ELsLUl_-aK^qmLWJsQm) z_IWeb*jS-}u~1cRAf&~$DfIKQrYP2bXH`m7=j>eFttyaif=U#W`>)0< zMilNv{b$iS3W6UvXsHS&?6>_JvsPgl#y{fDYS^H`C4Mlr&~QI3vCgh>aU9|qfFl+t zHYQJ+WJ4eN=*g44oFl+hv_Iiq^D!l$(1@X%WnDzdn7u zXU~~)nVjZ9TtoVVC1_-?UJ!fw^n_refdl>KSy>GR+S6#?{$D!5$y28;Me#eOi|VD$ zTdRYge{yzqzQlz~Ze#pU>^`T%!X9zfTr&a}lRrW+Gmjvb8n8r7#aDKs;q&s56RmR3 zfBksvLSmdn%}5W&OHvJ&VKl@afYxZ(kR!0T1-oW6(30+QTYUXOj7^WDPzZaym|ZfTE=6# zzRdS)hpa9Y8F)}-d3nA{$4^GDdan4e`FYTfs4o_poBy*(KDi*V@xc|-BZ_GDn<=cK z*M%6@umfrJ=K0ljb!4GWv9gMZe;Y_$awRzF_z0244}EY6{DLD{+`|h7H>c?3uo^6B z!P7^6^Gxr@O@C0R9+CKSnpN+qNDD|@5IEw`bH*{$P{huDew00m!UAN>a>}li88lT3)KgF6w<=Y}k$+MMg-9o>4(O5#9lJ-2{hlsWy;# z)TNEWqLc^l2mbR0mjT@OE7hESfpQD-MS`HBqBi=xMGkdrQw_pW&InbX`2Gpi;tEhm zpP+CT0R%;!Ohm%Xsoi=Py1aWw?>qhTwa8_!MZY=K^AOc4vWA44RBi=dwd!Biu0x0V z3giG*hG#-To|k+wx|#E=W9iAOZ*JMAY|VD*mvSyLy?ma`!a*#+fDi+Pf?6hl{#I2@ zEiJ$1y*-5n)s^Fy!4s*JifOspNT$hdU0QM_1@1X%1{nzxv`>lqJrS5rB8^L0Hez2K zU4~vzg2Zxl8FU^Xro$QNApj&bQrc>0MBNDb`|p|OuiPKv=3k!o^^ev~gaSL5boXcU zxR`iHw2%rp`9-gTetInVzHloo5;Tbbkw~4sE3LYy8h%=Q&0wwxiee9oeiNwB5r9}4 zE}St#k#}rCPpybsjSqf!SLm4ZdvOOuei@w6D(LgPK<-=AR1uEZ`jQ3+Q)R(?@4;;i zVo1H+Km&o@>`-YhR_u9d(>5%8p?GpaW}sU0AWvcFhx)k!?X$2ONNAM=s>T+o8k=6k z5;sWZNw8{NO*YvlA3QQ-VTCYRY6BL=<`hIr z_#MEU`~!s~{IHx9UDQ;>Rj^9`*v@4OQHPlio7b5vX{yy9r|xYzXRWn@kD+){;7qr< zhI^ZW?dtXJ7y4({Kw?-Kz9rCz)`;+=~B_Fwy77gn}D08GhSB=wh>L05SwG^FLoYWF4$ z>P6wSiajZh;5k&l&0Dt)M@Mfuf93Ay2H+P{sEHTrhjN?gAjh;5k*?w%qEj1120D>M z-Wnq2_JMFips^0R*BxkFuS7;J1>5>a6^p!JY1sAahsY-J5i3`-9(^@@4)fV2o0=|? zGmbIeTQH+EQ)FLXdoph07FX9poVq+>xlb4xa|zBR^4s<7eLfK;El1V>4(KTQk^DO~ zX_R3HbEIH#D`y}ITlH*Xr&mE#@--A67IeS-vrbkKHVp^s>)Qd&O#k!d^rtVX&KcD> zeu&U{5u38eYC&RR|7QnM0?hj?r8wXw(s6UE-FWN3%jfhZhiCL!!c2j;1}Yr=Bd80z z^8~Yp0(Se%UXZP+U)J{_nF~nE!fL788K1xgbhe#{ZRT3hA^NQZT|5u@-P^qm# zEpdf+HV7el4>gs;9JiHUzuKY6nVqo;p2sTIb$AEh3C77Rq1stVxWq^NM~gUxRFb#_ zF9976MiylUN1CdzD>!AUz_oY9&>F zPNn0IFq*^NN{awOKW#ON*@x05YE8cJ=@Td7V1kpJI#N{bZ?L=E@V(=}KXE&XU=Z&g zh6AD5e_I`ILjSrZ&JwkxL$R@tldcyO`ZXn8Kq!br!tR{)c7PiFo|C>FD=N-a`W za*PQRhczkJOu6_gf2R*0xe%yFwzv$9fRRMoRL-6g@o=dr2S?x3LwZM-ApD|W%+YKJ zZbp~la;@F9qA_CW<`Ud4QD0rU9DlCVy@|G`VFw=460x}92<$zU!D(IltcXZ}8PNSQDXAsV2AuhS%}+p~GwaBS}* zEr*D`Jsp;4RxeZBBJOL$zjrpK*b~8ooI+4K+K{oids`cu_B_n#h@{U$bj-A$B5)Ve z7SKxUNuxOslER$P9!WnhhH_FoAl>y>X54WyG`$SfjmoJO38u_xsXOo$JdHUyI&?e_XnxMalw259?6_xVX*MogeV8>(q5 zwKsDoA2@ZFmkyIG+L$i55hN^<2EIOJln}qt^gG2EXWqZ>8Mt*5Nrl{E@o+hdSFiTt zzN&*&BIY-!cel-IN=NNn-I)F^KeFB;wviv?x-BQ10ll(Usp<4ILkB@N^9cpx-Y3tu zD?Kq4v1?*C&%GnJC4?1^GuZg?4ne(8YH_~xuR#3+b~cqyoKoEB0+^cAJeXI@X@Dg< z%5!v=JOd351xtEX(LW0mEcP>TG7^^{@?x~hPb_Ra_fA6!x|4SLJIU6(DzP0caL#WC z2S;4e;ZkST+FQA#;u90^fs@ny3L~$`Lu(;O3qrP-FGKxz>#lrtQzEuxl3_W=8}V*s zT0WF7w}55^#1M>vL|4h*M*$=1Tuc)1C*IRHIG1+~a{IX{G&EE|D?qV4gVx1M zsC}qHCcyp(Up#rTdRFHi`yL{|NINl~ws7La@=238 zyUdv$fwW5)YB9Y7NRcUXX2DR;z54qmg~%!gTO#HksP>V%XZ?Ehbhuf$Fw3;|sTwQO zFcDU z2F#jxlB>^afDTb5iH+;v!ODR797No=lyp++5$c58l>by!-_?h-MC?x}j4~AWO}n0_ zt^f)!Ls(6gFfb|-?=G!(sd*1Y!e@R{+j9*jHdSWHt1lB@1m~AnEV&3sJP4lLA9y5? zcD!dcau9NNAh!OEr1ffq-ZdUG?xJPO5^ZmM%|u8qL7T7-wltRHDZDk9d5nTu+}YqZ z-TL-zDwsE<>D)sPnJUbE%*R)I@$BhS`^bz`R{+r_K*yA>e~s%Zha=w)v4JEd5s5Xr zi#v~kv3EY!$w@~1Yuw>s@t3JdF)7tAOUW>W9H7XB;iq>l2tpie0())iGo|I~g}u~7 z4MG+PsMa=r|5n_ijcNI$$EU{>8LdUXtuL-^-@7Uww-IAi$gyjHfPxqfuwvlz9n|7? zm>U3Lz)u$#^wB=mltn~hVkao-H>;SOC)78x|G8;Lbr#pF>qUT^UpHY5JpB2+a=Iw& zp}2E~*3yG=jl@ed#;TVig4#q$2p#H7Ucj!Qubk`SsMDRFk~2orR^WC@6G=>=YFOtb z&>uwAnk1|__{QoX4?|Mx!ObhYgT4K~>b>zeld_)cuz3s}3Pa&EITc~KM=w|qWSn{q zsWg`uIm@#SwVu~c1A=;Hu)8hC7m$XyPqtdk(jt7y~kFy&0Nw6*O99334u zwekWrtE)*5PeTvzIXJOCYIb5DqtS<_U3>e(Z>L4Ej|yk$Hu>`GI`+Rifim|}Qv4j; z5Z(%g&8VP?LnZu8WgHv@pRVQZfQgmxhczo-mjn8UX8>SLDpn8z>uskuP0_?#&mnsU zTAg}__aH$I(Z_`G8R;Dq!p#AStP+2br?kY*uIu2zZO8>z{473d3**B#6pOefm9BuH z^kPr1?LC!9&@F=Dj$A4UFA0I+WN5$|1b`9O(u2L)Ia{1MRR`^j4Gj*KlqtFY*dp;S zd;al9FntzYJ&4lnfEG^c*Q_}{&yc;+_PEW|wnEGZAdN0-w}TIwci>3LTR|LI#@9x9 zQ|Ink_gY!h-dxHU!-7gJUQVJyq`_bNDNC=!FAQEcI4VlRI9L^oyQI3J`hQvgvEB_c zYY#j}?7+7@ug)OIE9AryJX07c=v^LgSJZlJCxwFhu%u;v(LSsHJPv&x!Y+}~(M%!X z)jfO}(75$b9i2NE1Eaf!5EB7^j}m)~t)=SIU80x(Atb$=(6RNm0|k{vdBINPra4-8!g?w_QjpvXdgKd0BfvLNt>!N(SUQwHAL@CQBmHYrT7 z2NANN((|p{`VuV+mDiJl_XNJzi;D~WW}lxkh6Je6ErgLS~3(5=H44o-GKG;JTdo zn83IFRPOoGa^l1$QXBI72u@JLS}f)YcmkX;k~6w$&h^Fvvr#aZfMJ4Z?&Oj}p}gkc z9HrW3-meUc=B(FF%*il=b~nQI(zjYsL^ah(K-lUovTCtJI)_Iae1my%o|HZuAx1e4fP6d! zp5waS#b-oG;N5Ac>3Qn`i4?eH6gT%MRam=7zfrb6~+ckbajzCAbuVQ z7rJob*+gifz>wi0I*4!QoH6cs>ip6rOSip5>ctK5yRH zCrNpCji*&!ICpN+Vl9qZR8VN(4h6n^Ob6)T5cFmm*fkfj)|b|MN1l#|XeBQ4-o5kf z)afh7bFBjkNun++H*iE})L*pGIX5VD#C*i!;>WDiv@e8(5zBA9FpC0dlN}ALNEbZ# zdf2y4J&7d;>N~-56TnmQuxIQG?1ILY^8GPcq_%?Yscd1%8zbPG6928LNi(f0ZjQ7xm z7fYQWRjwS&sFOBi4!O;d!FHfxx!Y~}p}_1;hKm~sBN4vlInb!jj4sc}KsULnU7!0ri((ad z7IOJZ1KNB_7U+Z~YJfV5u;0A6SvMX_2##cMabQY)M2ARE^z4F52#2#RfRVTph%ErDZfoBP*_ zSOi$4amu(3egI{C|F6W>gw43Qxw_mV{$`Or8QAcA8d9whxdIRgb_pPT?tL7K5dF7<;e`|ORW=wJ7&(7GKivJF8p~$#$T``65lKj2_Uqb z5MD9wj-g01*iy?`fR?v$?0@h3LV}B?Re(Y;y|bGK=TD^s6T7Ym$Y7|X@1{gwykyCJ zry)&|6{{HRS zAFBn`;+KdINCMco3AcaYa^x^T3S z!;L4DaWWA^evWU_Kd6d{1Z)`Y-Fstilpuv^F3Mb@OVMb_(wC%JhxOCg%h>b@meF-ZzhTx~fnLy`xK4sv-*p3`z_xL3-!{$}lQQhJi>qZ61 zWoQv;uP$^s1-U4ohzy`rm_R^#oD2RXKC>q^u~@KrHq|@j)D8k)<||O9$w2iuV(ITY zb$_~x*rsxZhu%RYFP?c&vsM}!5_N)DZoi5i9}5;!lMiMC1xpVfPY8jPVLHW!Y#T;c zvdRokeV9klu=c;tD~^oZ(q5`obR?7s5(|J5(H3gN;-<4M*Z<>W^VGIxDFLrmfGx;q zV6yo-FXG?3CTeS)0u2+0lRC~H*R%H69nyU`7l$0A@)7{CZY7Q%vGJT%#W?B&Nq&0v zemy5~-EYE3kw=lf!?gSRf(=GK#Eij~{zX|KtDW{=Y#gbk*e z=##exh*2Ik)H!@~m(g~1J*dJP)5HP-Ns)&xT_xL*I?2DAiJ()W?}rW|_(&#`^6@`E zFyt?kqRFBkx|AL?5*hCwElF8t=vZFneisBl{3EQZto(##Ql#AW%KVbI4g(;lZ8O-h}d$3ev;DSdy9dQb_ z?eRg2cBh>}LrW{!VGqJ~7@>IfVkQRYdA}70h{>kVeo=Mm-#So=omgN=p#V-K2nJ_&tHEnkGOgGaOPmG=~nb`x{w_Dko_fxviF@24&HWQe#`-8zQ+tEss{jKBPa^qKLBOAv8a zYn%<_a)0*x`BJE$*9Iypx^YDUrNp7lKSanL(LpwxPv{S~l`gN_n5P1d+ca+pH2FxQ zpGDb&w@kIuRA_YS^y<%GmtDBnbm%@~Z7;C}1}Q!Q45)mffdXl`Fg~GZyLkGIYq*fx zDSGUm6di?Jps2Vw)8?3*18r2ireJuzYA}3wq~)DSQ>H9Y9NM>Umd~5c172LMa?Uz2 z93O{u%zDK8m$`B-bKzYZcGt+Mq+|U%kl<&ZY~_L4tyu983y<;UN(VRe@?Kxr(U5B- zHV41V$_i-SaoDAoiP?uSUMBBoq4lp*vx)|Yr&iL3qak2!N7t_m;kXQ^5o_D3Zt1N0 zYk)_=U4VETW$`8>OF4Nt{_=RKpW@7KjivgKqO0RAgVpRXj^P}T^cFCf$PqJ2 z{;wQB0_4{@iiQVeh|izc2q2h2tCBTRFi=UFfQloVYdivAqB-4Z+NKQ;>Y4iVDTxm2 zW7dV7K5fI#2&#`c&$3x3qfHe{q>cZ7l>q_+_UUt><#S-$(`D=VRhEuJG0!`Xy5Rwa z--Q9r;GC`|+7~3vhx zU%|D}P4|6qrMjlVZZV;Pt-ETA#J%$ZcCFF6^=Tyk;YXsbYqv&jcc-IgAon z6x0w&j#czcjTF?r*D}J%fjnPWMPs9+0K7JM;~X@utN+!kpP|+)Z`9}#bShmKD9W64 zHy{8rs!)Pm6beCtP=DD#H~KxQD06?sOPE2k14?2XbNOP8KTibSp%wJ%)68xi$QHCtMoNk*p)~#RFiY|R#l#v~-1^(>U z{{=m)poe1S<_d|?nV-T2+yxxZe2>Zi35@__zVO)ob8hWVk=#K@EU(%KPb0}kA7*@ zsCx1c?j+K6)V~e4ouXHc zgq$a6I;56-_`o8a(r5o=Ai}`_d_v4eMCfj2f@Wq+X>3ye58!feP4|DSw6jZ~F3mu= zdYB^P8QC{nj~}UMtPeCk=r(M!mEReofMrf#EgI;l`Vd{RLN6T>+3NLw>@>?QpGbhZ zc*zfLJ5Xs+lO|32f2|EoAE~b&HNJ+fM$?!*^3u;jBaap{=$Vf2Cb!>RW5GWV0Yx8MGcBK0DB5`%AL4-`1&G4T%9Mn z5;l@gw8TB$U5w7+6!d>PCBL8A8a#D7UpCj@wC@qZ&&|z0n_n?)HG057*%7~z&m`+F z*Z;qNxTYlmiB+}}kvFYpro-mdzwU}~lY?W*B?=Ms^z@r*|Dt7^o<2F#$r5YjF@JUoLatz3WQV%53f*4vm2M`tJbV$^UIT4$$c zA}2@N+Y+M}2A6#3>ev5!c3zx(Cy`e0q&u*1wtid(oP}vHZW&KGqn+DdU8xHt3Qkh1 zNH)y-@FCmgMVF@$4TQI5!=o(#P`^Xxh;X&+Snc_kdJI)}9lwO-i>D7$O!kJ}YG1-P>C22@`Z9rYNXd}^K5^=D;v+QPbc%xn zC)Z-IGKd^;Rw6{0<`pnt17yu^Bm%r_(VL0rfxp4@;PD_m!_A)})8z=kgkiWglk*KE z!mKo48MN$92%ly&*^=WU?J8~4STwtAeL-`m!o&%{z9TGUr<@Y34_A{9>nUAj3LiI? zMEl{IC^bFRlF8m<0k;vQa!*h@D=EOp9KTEsG>NS59v)s|n=SYlkQ<+o)N`}|9xlfO z5imSy(>w*HR+qso9Fe02a_^3Q0?bymMJ46}}I z4Sb4Be9IG@f92fsg#t}a>2VJ{`4T0AH~~tRZ+R-ApCF7fF%a|o&KbQ}e#P2&Vq_xT z&6|e6TE;#0N%D!|s#rEL|4kfwzrZaM@F<#{ZzG#2Y9CqmhH`JcOWf$coI^A&VjYu5Q_xYG@EttSBltFSyIscy;_8B>L!4GstX!57+lqJLMSl1rTj6!$Rn%5;zXB zuYTtglg1epE2*d&M~{TBW`J-Ubc9e1d?N|Hk~jr`} zbZKgL0wE)>tlpDxhKzyL&d9DV*+1_iiz=<}aX)GfX+}97@u3MY5Z-G&6cW{QpWSQ8 z&52X*3|Xz_-749LHem|mrP9y1+|>v6$PP_EX)|>wQd3DGk@;4RmLM^m=-m@Yf*?F&)P{98Vu3-L zfVT;xD6SU7vqCJRrALB;=%IL)oBO^q>0p|q&oQ^M1zq}BbQ8cTaTs72jqwWin9t@)g7yea3LdQZ=WhedDTJ2b&%lV z&C}I)sy~wdC8KBfu#mAE*TuzNfUZW`Cgu$0TyoH?lIjtBTdXoP0!*beHtMR}lXc+s z<4ap1kcg!@$&(i|71zDf$$C?(T7&42>sL2Yg+iMzcTY^$;0wYt3-3=^qOGgzAJfs4 znvMEIW#}(L`041UFQ-7&!Icxc-ptDiRU*fOl7fO$OeJ*fjLY>Fqz00Gi0L3u%uc@E zdM{;zk1W^9c4qVXai&1hNmP0tgt-Y)4#Z$ZdX84sWT}u4F-1H)IC8H!;Jd0G)^UMU`c!x zH4aK0nC~4ZOy;l8y?6D@7~lVC0jPkOQr$|pVN!7EWsw+3aua`E9*5vv01J|df5ZGl zzFH*Ci%a#sSurOY)9%XoYSlIE}4oYnUnJMF(wqB3N)O_*GA*PI6}P= z4RT#kuy~cf0|l9~@SL2N`ka?jCB>wvM!(TSU&bU{?$xi~eZ&h9IFwvz6pkL+Yv_a9 zq{Q>~w*%-RnL&#hj`pb#qtvNz&26IA^Ev<}& zMG9FcK8N%hl2J)K;w}ymxUK8^TK~Og4p}4YUSv3H;cHVb^F%sh;a3yGf8VztzzVGHE`}W;aU&88%w#gJl2>G`q%ic%4s1czN z{yZtgA%VwvcsSL^lq<7uD99v+b4)Ka8>&3PA^FbAOkw}eY0rjpbj!b!E~q*gt>OV> zLy5TyQL~uEVht(To`&#NeP#QKTn(Gn^YAZJAIwmKTk}K-{p6bOtr=}AS9JTMCfBEaw@IsUnKwA(J@*5Mu5)(k)K6HO#tC>HXQMEKTVwvpB`GNkSCOO za)$|jR;o7PSa>s35!}AQ%K{vl_xj@|O$d`Mm9a7G;VhPsq>%a+SC_XEIY|6i-uBTw z9IFo`UxqYN!4MrjdHupk~^ zLh~8@Ssx&&j41>8xK{W~apbK@j02Dy{9T2X|6UCdb%?~35ylb`0t;CVK2ZpXwSy&_ zTP{faOepsW)Xh?RQv>jVqc;DLacLQsmp0`XMHZCaq{+nTpFK(F#%OGsJ#i*9JX#Q2ZW83MOU-> zhJIT+{e#xH>PRAhW%h>{U2rX!1tdt^yq?D)c(NYkLmh1v_}#rr_PgR*J`+HtEdE59#UY_fRiVcH$8@wNLE0iJEm@ zMvge|*C00-ebn*M^ za1ECxBLYi>eUf{fT4L1m|0rdpyP(^-L=JO{X|PpBlX-ez&hB8v_2|CO7*A~rwSAW! z?+L7iOu7*0gS}Xe6?SIuj?XHH-^hT31xysTGg}Sl=nm`%<(r75Ri8FRWD|Ipqk-$Y zD(wTspe+wcrb2MokI-qyd+vyIk4H3GrfGpcfpC{;olU`>Q%~py{zeUe3MKhl`A%c{ zX;f-mup+kdH?K&5;A5vF(^9kj)*?ib@M@|Glv3iZvfJ*8*jlX#>qo$+!Cy(}XH zJ!t|9YBORguZRBo)h+K>yRYMSjMrCcrK8l!U$yP%hV%4P^->>2t~+o2bV&c^{ars! zeAa3GM5{-C^mS6RwoucXr?$4f*%+O#i(4(rsH&+lS@<}m)zm4k73*&;yjU49Ea&Z! zl*K3V3Pz^Cge7qMa}Sr9q-nCnBsK2F4VUa4-97iVz!BLItlFI>N@ABuy06fhIDkgg z7JskAOjC74V6&l_Z&CaVT2~x6r33ORA#mR36?JChk$Ww^5gWUumZH^Qb7p61^~Z^ z$4U8g!g#8|LoySAPK65mEgawHW8A#VX(1++9MkDbEdEIjiLFkf9Jg8XjOO1a(>~{F`GaRXUtv z{r%*eSxlG*7fJ$RMzM}`Y*ony|TkKBfbN91``yl?28%o~I;R zgSz%`1cw0LHEkIPK<5fcEKvm#&NZ~hkRks#c=uIR7B!#@2j|$%i6t#%q8*5Fb0=3$ zX55(yjwN`2G5jNF>5QA3)(095`m!W}GPfyVT*NTyGhkZA1r7eN3)$n{tA&}F`3s>{yc{PkwzW393&Wyl{{*2m7o>Oz#aWd#{!NC zE#jyfe&JQmSht^tVHN4tWYo{o&M7>~tDU-OP2+cim_vjY*!FQR;!VrJ&w-{O)xt&i-TKYI2Yj3kHM^vFpqLDLp0#fHL^VRV-{@q1|a zWP+i>L$+yi&o?P0Wm!>Ck=UHY#7yM;72Y}yWaZQ6&izXXzT|NSP0a_2OXyTDVIi4A z76>^chq#MKkUh{215vUTzQzQ_CEj-gmBk!u>ql}p1MJG*WA)l;&6-6Ze6{ai1zzmT z@8Xw=!P>{$+Xi+0qs+|ccxTuEY+G42w*mH_J$tsf=o<}v3K-tM0QeaUcWS55w@>Ru z`s)K2pU2#5nE)S}iYUU7&%8Qm+TG?iG%Ob5KYH}I%<3A<%GijWZq>*0&c~`TXgnYR z>dq_I%BkYmQ!egK*)@j7a}Pf7tC`>M0SL?-NS23~1g}(L?by7_$H$h2yP2Z$^XDbk zR=q4R_}f}+W4!$LIE(-wmfEHrZelzV%joi!IDI;X|Rfd|zD z`Y31(U5X-)%??}ZVNIGg-IpoJ$BmAUk0{91a3FM|_my0n zOG=A)$9pqZV?pD{vpSMUC9SlGPHIriYE<3|9lF_7x$*^tgT?wirJ)`B{erRIm_KLW zkC23Nx}@yat^{pKnI?7?aLvn8ALDKPB$8dx7}K=zo!2lGQJ4S`dM{u1i9<%3#0K@0 za?KP9sy3NRNu~j$;T@y@Hn6|ox7HU@ooK76P@oK4f0LRB_Ktvv&uJkcjqx@cZ<2fv zCivRirZ44_NETh&5eprL85ktF0`WIeJV;4dy|1!m$6+&y3X2k39Lrg4V^i_Sfs?=n z9&S(#F`Jy=EpwP{C%tY~=@$Fxd^12NaqfH*Gy17EDB2spfnq|j2HqT*IsDeGTViyT zo~RlCJL}_34!9Te)*^a<&Afv|r}eG|KoF9ANfUV2$#DDaK*5wMwLGryM@1(^TO@Lm z0|zuvpB2B8Z+J7C_*O_Dy&oiW3?NH1{nL&JyQ`HC6l=4s)jvo^zP zDJiI_gT$><+)S1%(Ls0M2kF8bpH*_15CypEKB5;-nzw7k(M_~pFQupzd#@zSi@OI8 z9k{&=iGB6z6(xxu{xy88Evxt3ZKd2mjxN+T*oqj5rjnp3MFUj6l7jkKavAC7(C&Nu z_%Y1c=R$v#?NaMNBSNps=pZgX91?J>_3li*SY18H(^y&v%a5!5x^6e`v*rCy2oZ%_ zTgR+QUK@{7G5Y*zXp9x&9~VByaRHPXJ)tdarUZg){Fsqi^tPwx-nJCjQU}SDaa4E1 z3FMR36f_*CU%8f_p%+#xC>jZBa#B->4uy`qsX|;XKuFhSK0#Lzy_V+RWbD{`v*vdG z557l+MWS20X?}ofYV}3&EYD!JoE1JOuU@!C?b*^~Ro}=RfT0Fvpg(l_Vl5?Mh_Ct6kb2_Vu z=+FNComJRgWc5%j67$7dKv1nNV<;#N`6tOvh7~PeZLM(xHnO2gbT!Er-3n)qF)I)4 z?4_+gTyzp-F5s$1)OHPt3X=L7um2F%B{JFw!aH4|)2boCj)#U;&m4{;Cy#D2!eTe{ zf)o{alF+3WtGadPBpE{=ERm;>%#yXm^uC;vrWgMPIgnePy8k3`H6k)X^$v-(n@zXA zFsqQ)iE}68>WVfatMlpuFPCY7>6$Kk^3%w7q64ykL86DK*gwAzF3c7`*GG6zx25S_ zJohHDJ|ht6ZG*rh0RzL@GAxfvxdf*e*e9?3@y4rXR$4Zf_V`F{R(^FiYUG@Fy?&QRg(Y3xqU*+xD zXWD%wH?(AZ0LqUC=DUP4KS3N`i+*osOQq`oJZxCFY%N&3ySq*ax(Qw-Hv2((X7B0t&Jbt zW;|*)5W$ur6tqv`99Kqc3S z?iMH$95Rf865#B1#c4NSl|$ygz(ik9>_v3TiRez>Ilvr=UaG!B;GVX1&iT zCtw%X&(YFDr+nEa1ppBiT*|LDz11R3hgRTVsfA}*9|#yUZ_Z_TO5(EsHZ1?u1&n2n zKBhn8oFcT%^-X%k=g;?%oT7Bo;$~QL-kx>rAjrIo!I2sh`#$aQchY%;VPT_6UY*mp z3UBE^=Ur*Uc`D!z)+C9A;$fjm_tXoAQIvwZyc@r}^~v`^q z#nlkWB2>s+=6$F@*CUn5`9L%3#dL$57^jxvWfCSyRdw`_C#DA}0cC`mgf3B-$vn%@ zoo#5%4;tfS&4Y!%2R}}Hp724DNqQaHxBnk)B8lC<4CHS%M(b;zvPD@M59KSygglfG zIAlj7t$pS4p+9+`*RtKtJUCC}Ws>?L4gem)z$@x%YT{s^Hp|iF$oU_lf+_IaIXQw@ zCo0^WGWSMRO|3!j-X3564(Ax|fa)QUhtUl6zC^k>Pwj(I=_z4?+}=QS z5igHz`pK0f+IEiS0yx^8U_>zsj%|=(4#3?WOzNb|Lshr5z1d`{utY7)+*M7uz<+p_(bC+?D4v$Vt$16)az zdGl`FPU_#*UvZT7L1eH(OiJiKcPLOt9*V;_1Zhv`MR^X1-)FTt{Y{TI#&gNhrHre! zaF1Xf2{}4}j}CA_-9yzGLA6S^$&Ob6N*X|sxI$l}Sgn(xvpYvmA@OBm>cSu+m>F?4 zhkt7I;A||S0GcRH_qA)+id=hOI-XpyB}u~A9b7X4w8PaoKQy+y$WbTRdJsDT)dLfY z=?58}0H+BuBM{04gR1r2aoC1H4s%u>Dw>M2jE@ZHSGcE?T-rwq(>fcubl(?@^MU4- zrBi74j(SXZHmXtqP2v9L4xvpcP#H)0Cw`VFPR-+PwLf8fiQTj_a8-XZS%gJAGFT&d zf`B06SBKWqL0rdZo-!@75;SVHwn{xnO#$5{NZ|FJO$%BjAYcAJ%$;dij(gkoFJ;b@ zAw;CiWNs~#v67k0LR7{wWiE51Ntx$lDMKt%XqjipOe8HVLm{)w8GC>G#r>@N!}H?kYLZyL(cdRS?vQ4D5C?Bc^Yq}{2MeVDC4~09+Y~PaP;RLXS^S5 z{`lO{dfZ?@fa#+vZQA4LwG@IIPEwjCCjTXpgX!hys>Qzgso{vp^Xt}P-Z47M>I-wIF9NJe1yw9zc`?%Qb zw{I6eANa9C^JyU*>R+DI-0vx9ShP)sN26wq1Trn@MOJib>Br~#*3a40WG7EA1M zhtS~X#DOafa|cOW*lNusEu92X#>O#b=%a^0yuA+q5;Tg7WkT;LB$KDH3#-p_hR2l{ zZkj6=mo}M%n9z|-rzo;^?ce{7=Zv^9h|`fsYI!^|7M0~Gv-TIhk(w&DOS*nq4JPrm z7#`Ip{D%azjZD+aa+_qc{A=kVm7KbhU%VJM4mKqC^~#+%m6-yn$TO5miIdyPx|nfa zBnvteSg}z*>OHBT4vg%yxa=WO(>IOb;Qp&FZi80@M%|lb>K`aQ;P5`MT6h- z8%*U>n`sRJk?6;Fk+&GU!`Y;}k4N$Ml0Wed>$h^^WY2+~UUm`8l5M2*gZ)Z}+|+m@ zM_ns5p#wbu>jrrBN~8IK;Z-Q3JwJE+>P-90OB`DA0Jy;cZ};m_ z`)GQ5RDa|KPlf-r&7O8hR%+FXCDisW@%FK6s}Vg9?AVEliLifyI`M$(;4xHM$bDco zkWY*aIsyl}p1AsvwL0oO zu^>L&CpkcGa5Sq#iq}GB#FnycrI$aNF|h_gy|Mq>%9^9%G0NjXnUOUfqUMffB)DTD zL(y$K<=EdhYi7kQ0rZ!r2;J?Wk$yYjswf?D8kc)~uTf^g-n~l?1@`KFyo^@d@`a`J z_B*z%bg5Fg44{+ZBeX7sm9+g&O>Ee3Po3MQaevmVTQ`Z=D6R~72iDSM>2#=0oglRU z$_IISoAORd1c1Yj%m(V#S|?p$-8o_QYcGQE>V@u)Mda)1ITY6gHA2X_VcYjyD3QR` z#acL#Q6;rY=k*~gB#}xa&iWFNu!JYBszvKvkyqA*>>7k-Y4^?c5C5YDz>qS-!QHHA z#pb7fF~N#1wAKa#_gTydAqz|m@cwa=r^kAuRb`pNk3SzDzT$KK_BVVv3(anM{Q6q+ z<|t?Vj$Pc0wJAwz|I|-)dY{&0A)7z7OlQZe>r_bEMF>tkmuzxnvh_OZ9u^58emPfa zsOBrNJ%dj)F#uWstZGGw9O~9|8shEk)NrUU?E-|u!NSZCwNr-w(Y^NOa@hY4xv*S5 z92$j3L)U77>-Tj8dv)DvxInDp86l%Q+tR@?^17_}DiJ6&?nb9mAH~Hsk0YyZ#&kkw zrcrUd0O$?~4+aAoXvJ-WK6*V#24l(&Je@J!GdiJ%y?thtm+Rx=+HT69mCaT)+tK~m ztLW+DQ&8I+R;@Y#DnyTom2xnavh3>|?*FE=%;(7Kd`%k)3s@%P(=G^9K3yUEqu|P8 z;2~?o{#R0`+`CjNmAQ<#7Ur}Bb&$NQ?Z|bqMm-^K;(_X(;a;GNq&|5-9SZ z*(kK)!qZHCvlJF007;5`S4%Vw8;@mAwkBI=vkgW&1{8s~BeRz*xnAqoXa;Gd_b6RD zm_%cXr3NK7Hs0mgcIQ*9ZchlFlCuwDO?iX5y6;s3?dzlXha40xX(Ef-KAo(i`G z;p=W8%7zuE+(Do^uTSme{e=FMWM_EEm1o!%~z}m5LTE%I(*b zB-U7-5SXWVlztet5_1MIB8OaQYk$WMvRgplFKiIupq7au&T(~FU8FYQSqfgVV-_jb z8@^%GU+*Ua4lrn_5e+74B;h7!(;~^gfItkQbJ^GLao35tp)-GH zaKYka&^sTq9yqO9)l?I=4+{P+s~TPq%#F}~NY6-tuJ8%V4%|rJlm6p)vg5~g{5`v& zt56o4FS%m%YvS_WGToUJ2N0s_<>s4nvw$<0#N{?Gsd3&hLPT;x0v_*0HIw}YmW|c;Wawkp4VvZ(H~!Yl~}#v_g}x<@xb)2zoGMT%L-4shnR-)e98e}R&g1bpcI=gYm7cn+dH36uFzSS-WB1I+|1^Je)bzL6RTs6@C)$3w7qFmai(i!8lZ3 zxuI`Jg$~mA-jXxwdL|ZCQ{aRwdCup^cirG)l^Q6eZTMnbo|% zvt6qi%zUaz17PX#!%lS_??H&y#TC_o#dH7SMWdkBJt6FM<57>wxvWW*=-`j3P<99QyABEbJHhRr)qt@tnpB~Cfi%Gxq5?`bA|)QpL)8AX3(Fc6Ol zm2X^3UW!PkaI^Wgv*PF2$3XD9inB$jy}OCiS6{|MI~u#U3CjVcl%|#zWkL6y1$-$< z4K_`$8(qrVf@Q^0ZzHri&FF8^!L93cqOjq@zAv*L3BDL4<}v7h&pekw zk_K$xG=$C|;5)0$-Pu==G%J@Wy0PP)j}u0wwEr}cSSyRGp~-B+86Sij zndRsx{-2DPNTNuj;6Ifz)ao~En9+R3jfkLM_iC*vrzD>K)~RRDWzXN(bWw4x*0r&p ziPT>`Y6hVmr%QN%+XpU}9z)Ahib--sLO2EYcKiF60dB5!QVqv}?skz2b$etcy0xvy z-oJKStBsAWPUN-bDmq^RMaftKyztSNx^E*QB1GoGN|=*unY)T%;2?3U1C`EB#|uJ@P^!eq*oz+;%>lHM(h2cGnb#69LdONYaW9eB+~n67xU4#tvdn7 zgQ+nmU`m6gUL4I6E$zY)&SnOJ@BhkAw+VlTok=l-+p}q)Az1LlDu^kJP8Xm&$gUl9 z8~>qu+Ml86?U#f+hkY$zwQtw`UrFtE8BX`6y(`SmfM%JOD|cbK2Z#h~3m%ujNS2u* z6B&39{@7(@y$3xH=PA!0!U8a$*Y4G^(!ZYfsJV+ekHULuB%e4f>B&_PkTgas)9|nP z8&GN$<%H>Rilja9@t*kOdCJfe<_rhY`vV6KgV68DIcc}?+HW0mCj39K&HLkdHWyEx z3?z&|uGT|*c82(FR-k~VA&o(v3laFN4&pG_jYE!Hzge>*7GFs@u){FcBDA>&eHoGH z-nHu>o&k&d+&(rlr^U=lw-*wkh$x?Ky$tvn zpBC=uu;^xcbN>-Y7f#4l0DYHJ^$nrjy2NhUG!G=*8x8uMqm&!{j|7xL+n~iiN^Ybj zV_`lBG=LiWJ=+8&LEO9d;m}Qv7kDj^d|sW@cl|TCGhsu}RI`q~_T!ylyUE;(`_)(j z{Ya7|gC&Ee1|+LwF_9+xV*@G&u3UHGkJ7A54`&E8;r54LugZYZyz>WWwyg>H#18p`-ScZ& z_-AeDi4f+_QObKz`wR^CwK*Ga4egv%1trT~Pbucdtp5F{Ym>~)ATVAozDGl-aTZx9 zAbTlI;$vlrRMdmd1kIa=2g|s`6+^+{__j{`N+g+-v|&_?xeRS0EN`R-u+@I_k~{SA zK1<#;!o7PoIJ-7iXgmk$g+b?8?=8Kx&-LfuOW=(L{t{Tf&2-=Ygn=Nc*eHlQLNoFb zJU3SiWE8PJeGMF`D-Eip-?K z5!tSJ#8ET0&m_D_9>oXdWE7HKM+ecrLcr)vW@3P7us=s853w)pNx2|j@!XQ$q4sB} zR1>QCidMMKkAloV!lH`CAXg_ua_Bp7fdGXX-U=#K#(ogcq> zG$gFb!nT#!OW5g8%erPkt+oCot?r_>9_NnySb|y2aR&LR5?u&+@n?9##bA*$#JI0@(*QMW2!wMOEQ=WJXm$IAW zk4vxLK|i_D_S3HlL1GpP@m$BD7q!iu`czvh!Omd#C$GuOu0|!V1xcU?w?7>GPZSHq z@N5=f80en+w%pFQR^V5!2SE$>aoND<&^4I!onY5#o}c^V(~)9|rIzEDUk3f7CdlSn zIatt=1;dcDf^O{lCvF-+hnIVJ#)g9Z3%KZ_lA|eXeVkCq4f%WHM)w}nf(g&CQ$j&IrNQ5_h=gS$Re!f0!Z`ux;U;n7n!WEz3 zoxN}E9RdCEu-EBIFUOFtG(n`n80{l^-FO_5+Zl@V`!}AweE~XJW_x@OZ~o@XfdBc0 z&K&L5Z0|##acI&@?Get7wB1+6TYGc~XJf%lKnGD^jh6M2#x)pO`e(<@wT(s;7i$My z^5n@A`H@fqO?mt$_$AEzEqmLa1?q7&oM2>w$hiv9 zejK%(*iPzN9VZ~D2b7M9%uKO2@cf7SBZ}gWBGM8XvJm99D!+an9uPOI% zkOq+8_S|DUUT$B2GFmvY~ItmBT1@}scrkP3P7k9D+ovh5t`EP`%})y zmD*1l9mBqcs5RT+abFiJz`$4Q`0U{pWqv+aD?=&YgDc_gg^W?P*e!2c^&7at83G>l znpk}Z&80Icy_$=hWG;1AYYKU75G7&VTNM3#gv(l9|5ekGTX4S8BiC0wH+Mp9f&eA$ zJZBs2=%Vb&MMdzvGV#9J%xx6+xE5`_sC8ZPVZ$)$r|^&{^S)0NmEE(^B!?fMqKI0% zR$iV)2}|&|bsSQ)S)3#J0s!wWFiHo)_qJwKj*%cI0Q&o~H72aC-@g6Q=FqfC2vu8~x?W7bsz8u-3S%PDJOu_30Js&#x~akIM2Sx{A+{PSFU%Ohp3{c13&2 zU5}B=H&)?}viZZ5TWcduoj+etl?SzSc4Xq3pNvxTiIY0N^W~jDEHk;I@9N6GA1i*X z@4r(pk_+tKv!~y-g1uSH*f2wmZ=6zSqNzUS&H(iyqEb_r*NB!2G7riC@43&S(~Wh1 z?Tm?Oz3Ix0jIY$&TBe6Fik2(dEE?O;ACJMVefx%@k0kPCZE@LH?e&(=Q@^~q@lyH% z&I}_uJfnmUE7tKUKHW`IlxI2#Op-e^imY6TR);7Dr}pg&stkY&j|%(E%9-yg<4#;E z5SMz&Nh;_2r>DsYy#hRzJY*7x*4S^sI73S1RTHMouP;@@evlW6mpL4&(HC%(0%tPF za0fn!Vn5%$W_=F}Gc#hQDZkN@X=augV$T07`)bvK*R;c!{Yt5cK+yY7M(~mfZxs+t zy(i)8mC1T?6Ka!J1JS3M(cg&f6R43?=?Z8z`tzgN>1NW+A>C$@C=j2jNsmV;e50PBrwkCluUD97 zai7;iKpnYf0m-V{qD^zMH^+2-m(eF@Q@e50ko_F%w0_tHU{ynk@QI@jjn6Dn#v639 z6+SB@prj*B8#e|hSob<@Kzk%wTAcg!N&6YKAV!xTn}s7<+l!-s-7Frfx{ep$P&$(hZ!M#x|rh+2;w68 zk|Inx#(REe&9?5`nFRLXcmH@UGLJY#7^E|CZn0Pdgp-o4)m>QE8mlv)5)n>1dj@7@ zPoTA{KlEamXF)dADvVkDZQI6+>qaidrcuI3pT&3DA;XnElKDZcHSqDNN!`Z!y+XhC zKGU(F!FbFlriyfV-2aElEKy<(#jPaZ^l)?d7I^6luhNm!G9a&>0pD9<3LzT|?O&c; z{%vtFg7AFE5_N{q>S+JAkQCfunM?pwa_h7iJ6XGrHxi*LJvg2PSH>&%0S!sAO={rj=`ki5e3@!rtjCo?HTRt;^5>G|?S)>}^V3a#Jrc0(uo(i5W- zmVQ1qVlh?bd>URRsOBU&Jf9|-Ms*Hf86g4=Xn|1uY;7=l=ZHQHd05JOzMOW^8fev- z=ycNLNmVM$T8^cd0Ia~yy>rPl<=UC8h$KyNyAgN%Ba-UJ4(&s^t@;r7f9x))qN zA^-NipUKWjbW1urUg61i`0!Z>i!>F*c-H*ajW?`iBF-;p{^Of__cnU9^D8})v?$A? z?csw|^MU)}HFx{k9*B;9e^>jd36cReiCvD|Yu8@--r)A1z3cMD*WG6R`6>k3vka%E z+y5H5_}kz;4|k+i{!CFPb5a$fD1~u*gwSI9M?NDvZ)-)`t1#pHhu*}+e2}oSu}_hR z6kXw@TP+4Dvwh*!PQ*HGDhR>}Knv=vDLshLT=b5tL$$kOxGmNT zPP%ldKMY0+B7LngPv~JpIJjH1>m%JI6I! zQ~7tsN#zE`b_R_VX_}2d_Hz0K=gVloaQPYp`=yy6#6)q8+w!*d?y+r=DKitA3PuxV zkd-K#rt&`x)ZOaSC*)^2qE>=%0y^8^`vkbV(^j#6{BgXQ$p{L4Kn|=mGdQr>uV?0j zQ^^k8(fe?Ecl1-_=A`KmCWU+UyzyI;PY5$l*-evQ^LDQ^b9o{F_(>CW^!vwth_4qI zXSg1gEam&K<-6FfIKrHSFQE*jRET7@eSDrMBnCTnjTdpwpfH#pGR}JB>7>a$Oa?(E z0PIg$W8u5HFdIZU)mB^km>LKO$mm;fCpC))D74Bqri&`x(lt}hhVsTpAb^Y<4>j)Y zU}A!-fHf=*O!)rV_t9-{FG}+2vVIM2PQUXgT;$X50U0 z0r>8;0a{MvvAq2b@D&_92>ROTtEHt4YW2&d>1R#kDKGFVX%aNuDF@K>!%`9~ zuF?S@CJ&&G>OZ~_7(ttf6D689V;r3SpxA!3A4U1tul%daFN+o~{OF@uZWC1{(ip?D z@7uXy!^5EQNAn|-N2Ah;HxY1=Y>Vt^-o=%qa(Z$D9D{U`)W#zD0VH}|Y45-2(}p7& zZInw?^PF$vDU>}La9S5R%|9DKrq?tU{kL&c#rd+t@3>CHk2(5z-o8TrKf&d7m+nbe zy|e7UGg=O8E5eY>iwdZLH~TyoxI+HZ%iaAvUBTbrUP+Jw{SHnT5k4M8Nj*gHtEO+C z-sM(5?tQ~XjRp(q9HULEXLYEh>BEuRxctm`oW|9G)&P^&$XGw^;eDK*e$8vjPDKZ0-FE;Q@nSIwnSSN4nY{_lCKF11qker)#O6z}jVkmQ}l>nj>isC^_I#MRiY zylqWo&4P{BImcJm?*gAmmw=^;b)`zPr(S%F2uQ@*FZ3FVp@EO50BK=|QmICb(0<8r z2Y$apQR?3RHO~0iEX?$1`iT|b(Fb!}#vQGWJZsg0P8~ZM3^I>tj?NF0roD|*Pn^gl z9+g^W{LbsQKFuvkZL8fX*d`*+SyY#Z*bwY~|AeQ--@bio+`&ooflFjD>CHm&M&P=% zOaW9IgaaK`mrZ47f(`uFv{KT4O)FiF032{(uEeA7=)#2~EWUbF&OCbVt+#h^f2BdxBR%T z*k7#4(BZ?+eyvypbPt3|B0Yq&6z(8*z`WX$Z1@qqZ0moI80Gg5zr@yFdTi)*As7Ds zpU3a4Te2YLb~n9_IotR@nCibMYG->2CY%=}4kliU`kh~Y8V>me!xNZ+4&BXK3K3ToCh1Y%tL@F-r_CZ9hB# zmCEQlG({S%K+0i}nf>nw5uX%ME}sGanjYct1YbeCp9t4};epH8$~bA#$72WAl|J`( zDiTRh9y1Pz+(rmpNF)ujNMpU$ZBBSypduqoXhP5XYI)>a67{&@>^f)vWx$`&Rzk!) z@^E4#UfWYAy8$vQ^&eQ33)v>aoG5b&dEJ5f1E+r|r8!Wy(uFh9VY_IyLzqD=nwr|$TuPAJE* z-eR&qX&jnC2JQ5HWVei<%QsdN0;%29LTaAu=S#op7 zW6O>Qqr}&MKb+=$-aq0z|ElfOat@PfOV7tAGRn8~b>q2vr7fMt<{_z!HQ=QEewD@r zR+zK6JB+K=@S%42b^l&6nFuDONfID6?1@9>%RC$NbfaNGVcy6|dLtj*zds9D%q`ZF z-*p(+?IhJ2fNmfhVg~R(8WW9zt!y^+H#xz{(}8r9ZZzs^;>0ib$b-tjQJE&mSk4(= z=@9y)U)#3?HS>(JBX0~TkUKDQv~TLR2M$%oKubMf2Pa=RogdazA4Y*B0R~-clh}43 z`y{4L5w9=gtCJ`-HKW_4cAg4?wLPr5v#AFB{058kqEg~Y<-os&sSh+x%{(l5Y1<-i zNtm;;WUFmVu5%6lahX!f3!yE;YmB)*N4gx`&nL$4gfzRzT(Td&Mm1CT><37=9^Qfa zkk49tA4aCRS-A~ayy_YJJ>$L!922z)mr*ZQ8k~E{ZA)KcM1#zJ>c)*yLW-H6m6nBg zNe;=fT0n4#ilu;>it3!`6bcNvR-08@=XXWg`}W~E=@qq7mvDaq88nrNGq~QpH*Kr+ z0=oq;Fc+v!ng7S1e}<#w*LJq$3)FLXcD-U5sARChp_ z>#}z$TIKhTmJ|uZNwhM#U{mL{vY{&jSZDNvXzh;Ea;s_69Fa+lMfDG$^hT3>`TeT` zcVS~i5--bqEXb{bX2efqJ2D0OZtq6*W<^migY|<12?9Tfe-inEibBr=^da z{TfsroTqV_#Wjl5OSm{7viX(~GtPIs-e~;Nq3(TsRt>$JvY`4y6St-7^VbYHJMR9V z^N$Ob&WgTQ@%!O{=9lu6KlA+al&E}nP94ZReA&F>*nx+yd_DTPDq$uuvaO944FiG+ zKt|spaW~;j#pSeV)0mGr9og2|`F+RQzWEKi@O>2P29Orj14Z}hC~5?ignGBNumA#p zYQ-D3Fv{i!4qqFIgw!%5SOOU(0aJ?m(MlU3Bq+7vTjRZpo0}ggw%k6qfgtHjP0co; zB8Q2PUP)+114f|Oq>noT^Q;ZinqaYNI$;+6v9y2p8F&Uu2(en?u^01$sC>7D(zw0c>3e==yOwuhz^8kcN3x z3s5^Vt$m6OT1Nst;EeEBn%~m`jNwPZ3)W%|vP|N!2eEnjbM1+d?VX)_4C|A+ur(-> zJS{L2nDF$P%ZtX)1{1YDL{|p>i{*-T-O#|PM*td@%@$Jwl>dW#ea(p3@lb07CzQ*l z=)u*;pcIo^ZSEISdjcD zcMddU_LKDpg~-ixKV$EfwXyMW>yz5Gu+l3(s+X{HqmItbcB#UN5GPXQSq4dLWW?HW z*4-LUg~`(?BEc?#i?hS5EAR*q9tbVhq6LDwsF}n}L?H$>j^GP5&(}jD3`|Hkt5ADr zNJw0wcV8!aq?7r`dV+X)jjBv4Z(|eF<`Mb7OKodCDpGyoB#I6`%XQ6fqXv0;uFoFM z^gU&XWMJIdHwTF1A;Uh55`JT*%-Y0_Wm8E~B?uZUs-m!anH zDbqK&>hVm%2EyPNU{pM1bj7XW}A&@D{iI*;~W$5)~Q(T#FzbxB2ujxIgk&6 zS%(33!o>+#7lkD2&LrLKQL|^shMXdMt>r1isnSwwI7;0HN@mZYLpNoo?HJ&&cl1A& z)HD;vP3QG+FU~hGt7ci%#%61a2CF){1v(yuNsZ<7BK6?*=$G5sp@LJTL?@IhrS^ad z2T?l=ZqPSkA|;;v`NggsqJtkr64lUBXqO4%0(~che>m8NnLJHSZVC955C$S?v$bDs z-?-((5iJhXINZ_CkINZPEl9R`LiO@1+9x2?^(JrNw$fqyv8(!X{&D;6)z_&@BWh4k zCQo9#mn%U-|M<8~DOa-D4XrPuzLE{$zyGR!ZyR_qMcd37e0{CNp6 z7PE)&+fZj3{R6+fH3P}9*2&aAF+&#&DctP3@H8Zy*43-GeNp}ARXAU&P_4|S%mxUV zK!*rN-TwVImaeH+$FHJZ(JUQ@)_AydC+vO8_jS5*i8(V=BAESqiPI z_k**R0X0PO!|33W_V4{08f5GHWTPg&RkOegpZ=c*wT%aLq!Hd9+GUCk|KF?ltxxLJ z4%&lWA9EUJd18=;8dHhSZeVDw3te%6t*wQO!W;6hL9=%#NoS^yugLHvJnrUK{op(~ zrCq+Q#zKyN(rIvtK%r}&B#%=ru>%L@4C%rii4c$C+{Y30g$jx$CMLU(_xudFn16-A zjwGTvFyX(_d~ry5J-40l#!-krA!h5Ht+PU|mx0zTYc7k~y}R3s?g4cGUZlt-pv7EF zPEEzBwhr=rwwHC!hzF07)|}0KedNv>uB5hEPi8nzruS|$Ic?rMz8~92TpkHiZ4qD0(2~l?pw(d9ny_x| z`ECpp5I*>!-b=d`J@#?0TMK@Zz$BW+h~k+KngX9F4rzp=VM8Zi#^`__e6dS~xx-b6 zpTqARZDz##`|N6IOsIw*H7aQ_0abqn6old{FcU7cT4>8lD!Csa%08N#m5=!#_eUp= z+3}%a-GZXGVFN)ZO9^k|du@ zyj>X}u_RauB8oKq5L@W48w3Izunp*uX%+VtLbV}s%<-H=_ zZsK)DSLqBEEd>?>v0&^WQ+jc`uAJFD&!aD-Skp-_Ldf1y1?dHd8H(Za13CqnWpm8M z6D5v=hh)W=LGEK{1Fs&O=sV$AO1pT+{=+n4*>7%~|CH<_i;WqpcH*aVr;@OL2)liN z0g9_EcS`&eisFo#Q31fIo}%IotZOT@1~pW zM7}qp5;enC&7GTDydF-7r2nwe=P1RVT-#`-%8?k$c8UQno}|ow^zfmG)e$2`K-;)Y zn|T)y;&_YkWpU-uupqkZUHkUA?({e!u4ddg^3M*6p|$e7Q>3O+rY{Pyg2{C5g#v^R z71PEfJpzt44EPx|`Ui@FAZ<2Z2D4SopWY2@9nqeONoq-%ne!vuF8*PLDTsK2^M78F zRU(r^C(X}Lc~;Yh9$*wf(@LN^Ug*A!&pz++pVl!9F&NDnx^&5BnD8Ra9J(?r5#)_% zXS2CVfdB8K?=T%Y-|GNfIK2{qMk{0~fSFF#$nH0fYBn(|PV#(H=*_BB$!FLjj+j_{P)wht4X4!_;`2)L)Lg%cSCzjAH|0)GU|^8)B-^b3m9>?^ze7cH z^Jb+fJ~r#$^EA~~*|wQqOkwQCdU!3(j%(f&Eu~Civ1(K=CRUh10h-V;K~+o^^4cJs zRvpjvh$#ZpmtBA$YItfV-o3=gcFxWbB`;WR9naK-)|_kZ0FF)RIUo;SBr?NiqS~Cs z2oZ_u0aibW4`86?UPS1VCYo&K_v`OT+{WXeNnq=S0l*(l`%s#BXh@v7XJ4m@b?8*d z${LMe6r{HCBU%MoTQf0?U0N;LFG|H+++<8e^$Vyby<98%T*Jds!|aRzlc(flF2x0$ zMm>}X)N!F!i#Sfa?avaaHWxDKii@~0uSR!gz)hAmSYVWb$O5fR0+^~lGOZq=CfsU4 zT;Bj>J|J)LW9~JVCYQiWAuflT2N@ZsnixVu+^h2(>WY0w{$+(58Q!lu)BHk0o(vSn zBXy^2WZT}@lk3RWWc-fy@ zrYw8sv*TuN15ekuBF@=aW4=tjoYu%`ytk{INgx}zmwYDmM~^Ww@uz2m@7Jt~@y*ED zNnXM$>J+$3GURVwynSKt(Ic%PJF_T9*J(i!51 zp}Baqs*DCxxLY__a^h`y1UoeVMTzr(fm~HNK5qn7@oAb9l}sHdt%GGu)fh4YoOwPq z^UUmWnuwX5Ui2XR*4m5OV@J;cHqOv)GqFYA=B-nS(&ME@?) zjt5$eI~GD^kpT}!x;@Q>Qb8u_hD_{ay>-~Q1O1Ul6l29zP0HsOi)s!I{ZPu4;4D>} zv~)9;10|bIcw)`VT3}|*_kCSyUn^IwT97rwC8!nfIEk~oT@+cf!CK;GhH=zg&!uT> zMb&|bXh;00u3Z-zTH@|=fKJpJg+l>mi|62BRarE6!fxmZGb)NkLltqIe46+NC#i%!Z&V#|vKH^CP5NkJw}c22YV`r&ys^%!)aLPzt^JK~M- zI%wyo@CrHYZoVF}Gt@diL#500MzQR=BXW)6^n5`e8=lO8V6$m1#Y5s>B*#FW@YPM7 z%1NphwvC#;G^z`v=^s{{zp;=)H8&mT0}#!fX>N2*krb?X-(;N>lrQ#sqU*wMG)i7y8^pr8Ar2G4G*E^MN|@Ua<73 zhb}o0K1@hO(!U=6>qby-^d==R_dET^Ej;*2Id_B?=}uYp2pd+K<&K3_+$Uej5Y zSJLO%( zh&TU^hY(ul|83ZS*IyhzWxmPEMuCc3%JvVq0yH$Vq!=cbG9}F~XUbu%`|aO07T7Ni z^4q(aEE8T`v{bxl*9)XRQ*2RXnMh-&qQfm*P(3eOytm^r=3|)&P+vxdi;GKnxw9(j ztrI*(c|yp)YP)-aTxYq_Zx|zRDmK^s3j4=qq#v!Yyiw5(YpQLz@(vGNw)0h|o5SDy z&7P7||Dy%aBI`fs2g1zjewc2zZe#uOIB8U5h6|)+d(X6o4<8z`hb>*eMbMwQxx3R( z?sgBlbgb04h)buEJ&|0NY*K)nQ6-X>Dgj*#&J#7~S(gAKu|zQrSxCuThoGeYMM1VM zdvpgSah#JDfQyyB`>WYL=g6D~s@jQUjI`4bg^X(s z1vC8mros~@Oi-aOY5%=@$IguE`(fgX%qkz>n3|Xv41~SO5g%9&&1B##vR(RLn-MCS zWFNb|zQTF5x1@+8L$>*AHyo_fO&QV1c_ zmU%I{Q<;@v9TraOsUP%nNO}9{0#gQa^;e*#2&`=xhGvcfw`z|uWuIT;{fZxQ!J>BG z-48?ey#gdDQT1b?q?EUex|;#UX~;l`M~aR907$?XaaMJ#%GW-BmG-q2wKqL>2`uQVBk<`G zza98d9%qRejHKshK3oZf#YMJ?cS={_NhSMM_~*x)+E=DFzoNmAgvfWugj&3Dr_p=7 zY{#RFV-`m*ewcALqs8+t-`5Ol_6a)vBn5mB>KTRPKo~+r+y_L}gpbP>FSeoF)z`v& zYdORGb>;>Kn-MnopQ+;?nRggGc!Mrre#I6Z0fDx-eoVGf<_lK9n591>8R$U%A6%agOJMlR;id-Blq$FJ09v3UVmCuQ=fI1OO$IPNR2itCTDX z6-}eudW>hsOFs?DCr@+=AeFT897D!h%E3L{c2V2t15~_yUaTydW$ znGq2r)HS%5WP=hVs)mk5D~L%$7mfsWr^mhc;E*2!Fjo={3R7qWD6S1KC?|_D8DRXq zrZiG9vT))pjpv}^@HRl0g5Bc&b&{ZS<>!ZxPG+eZtXHRhv~gu0Yp`$8N8B~J*P@Q{ zLjRS0W#*4LywY?+B(X9VEQ|lcLDdv`B{XNoHibev8GY6I?C=@1=U+a){I&GqT^?IE zt3O%o%f*jHhb;mO5i`2sMCPHi(xh{Rj?O88@jMHQk<;k4y%W_cn zpXA94h2+S(_)!$uPI8W^`jmtx`xN@BS;umIlw;n7>T(tmKpib!qcC-RmbsSOr&OQz z<8x*<#VtX-2nMV|HIi)sIJM%LjD8<8ES6=OXA$r`=MIat^ge) zWY}~`^oXvAN;MX(gcMQID$m&YV^Q!#Ky&$!{0=l!NYFXpc5vL zOk+KA+r(65(98w{Od8K5@rS?%;8f(DKR_YG64&_aJMsY&y3BFeZlPO}5=mFsq!hd$P`2%NBeyY;XU$`*-1C7By zlpK*&9{>CAvcyEbYbz!o!M-G?J%J||x-iu&AU3cZiOoyJWG?4IfJB%EX!Yj%^iQt_ z02a%HWh_b?nhVrej5f$eF5Z^ZTq2RHSq4Go#dtA}=s|Pl%rRb#IW?vv{Jf2R*;$^@ z7n@U`V7icGdBr?;F7Dhf>cX5CllqJ8ZLOeU_(k*B42}aeE=P0dr38LYTht+@CTa24 z-~nbeiAmfdLrc1Xl8N)VD5yM!7psl)0k-N)uNZ5S-vlxomxTF{Y+;~QaV~UC;#cLY z2VtsV2TH6bSV!TP6T!JXMb`uRTX*k0P#R!&8(MLIDq)Rs_`$pq#)=YoJ**x0T8D^@ zn6ObL_H4G+E}@a2AaEK%rr=aap+OBLoHv?j0Kp;uNvT=#^K{7Q4-rEO+c$;wB%`0E z>|~C+7KloW1;1ZzurM%ZK!Q6OyMOLwBhJv2!*`sVFVs^4Hc1hrpg)<{G z+ez$nhOez)hIPm}tsBwxf6QX{T`5NlLb zR(I^mjMC{_y$nEI8#!59gr-&e0LMXt^>pA55^j2wa7Z^pda>n=$@e#hebl2ExYxR9s8@>xqrdJ?+Bdx|+|&O3*`Zgq@JrklN;g1gf>!a+ey@ASio(b9NT4B!j#3S@ zWYa>-{2F$4)1Q6DUP^F`_>^lG($cb5RlytjsaY3~PGIl-!QR`9qHM{=OioEkiUyLD zeSplrIj!-OTY^yO-+tvCja$I-hFit=4d~;`STuN1FvK#p|=55CtRqNGWn^a62VU3^Lk>r&yvaG1Oo0kmYfc=+9A z2j-E6v=XnHG8ZJI%}(a>XVH25S{W<%xOz)jD|*w#8uDpWTq>OZfz_@c#Wxk5agxuNwYzv{2WPOwkLANK?U7u$_haV~B$yQ{@M@F6Er z{`N@$T{AZa+P#hySP_a}j5EBT{fs|ahY%=L=!`EAR;(y3n1{9< z7R(Frf;twk{R4U?7a)Wf3OG&GVMIHfob6U}lu$I02Ci=IQjvgC31>up7sHVuzaD2O z>7>&w_7#J2hT)8^W8{v@TFsHS|0+z-VUi#i(gWR}r;#ZDORW?rW#=C?%@yM3n>sr)uQai{o>K;!V0d z3D)Q)rho&>k&t4x?~CF3$&~qg)1eOl0rQb)cu#Zb zaOsRj%2jBhK`aJ{ZtoXpJ&2c2u!f8ziTfzJHOKt(k;L8A$DO)$%TiT1Bmme?O$r{L z7;3`@4kIoU% zG+%OlU=@n2@u1WVWAWYO-7(CR) z>hvQ0=8^%{!V8Zm5Zkck#;bB?v;~qTAPC^nHLa<^LkcUJ2|$K?^ntL4nnmLBV+NEa z&@ES>>!+<}(2z`eoBV9^7IAaS%Hu^ZKeVkR`StPcs$RqI%WuV#m}nIkM_>1VkbqE& z8A$00HD#|4!HfFr*|@uVG?{8|-_xxm7plc5!W+;wNTQm{H1BaHQ$c1vL_=7|Z6rTj z>cx>3sSLjE1-`AYXAbV6NxC*NM&Pvb{;sRrxLwJj)pp!PYD+Pnj6^_Fq(AxDHb&kx zPUDI)V21q!f^#N8Y2bhX=6!bq%8Pb%OXy8Qs&Z;xJuT4{Q*~z9#0i z5SIsa9|kH2^ertuE{L)uk;-ZpP=Fc~*t$T)((G~?;ytxBIW5l$uK*F9CmAa`8qMxJI&)2jJRl)~k~g~HT0Gst)s zW5`Y~hNlElMHv?(5Z^iUf!d*t4@$Sg4&BGEK-|eU^rpbk+&ghi>p$bY74q7lO0!b} zwa#zCt5q95WUDu=H2Lp@z)~R2bY2DxkAz$Lbd~D{mOQMy1cM)F&DC-KTZPx~F&rlV z(v@f`kyl0=48fSz@7>$O7?e8|A-|flbvvHG^zHriE=&n6rUr^DLW?2q8_Z4SP}xiT zDic?LXfM}Tiwz_W8EncgoRzoyR94iqbR~8+@LyDBLsU-!)@+hL0DaK^7bEb ziN$i~l5Z5W3iyBHzw5b`sFL4Am6l?DS2s6(hx()MH2$$}Q{KruHfawa$Yd|1w>93@ zz9~fmW41OZ`n5jDi|WA3l}F@L9I2suA=KgcUZj(Q*+;K>?n#yY2PYKZ?4FUQ0+@&` zw}+B!n444KI&kNsM~~)p*T%%~)tk|GCea0JKK2{WIT0${dIbQE3z_c;3B@82ZdI{` zHR9o%R8C&17|{6*}(a??A|Onai~5S{5@nb4A=MRpNQC%=OD$!|=gZ6nafofx)m z`aIRQj5AI7^v`6Oi2Z!_KG0t7QG$>-$zzUuu%J5DEBvK&(J}t3sgGbGSUTAHVpNk7 z?c0CrXBw(+#21_g?~GIE?U>9>{$&Nz! z&>f^)sLo0phtvszCTR_LZJ)M{r~=Ah_AFfwqvw0#{0k73Bo~$kD*|h!xsbTz^f8B1 zY$EV{0y4BlHR{t6A3hp(BM`*LvxT`43ar z{0D++lvR~)lX>}im4BDK@2@dWYRgtA!N<5<5lADTMFq}N_tQF0?NK(NU)3Vfi)$Tv z18wF;6Ph2TLU50oi7_tWQ!bRSw}f#xPW=uFgK6TiF-o<> zFhJCl3qPobR@Yo^?`(jb%ENn~$IK#x8`+l)frt@IkA8Vp3yvr^!*vV^PzWV=x59!9 zG=dj$%$)LL;1`q;De2t0b~Usr2EP=E6Ca+`m5_k)QBINrjr=>14TVJ5TmS)tFB!fX zQf@Uz*)H}?$%N9R*$3fc+3Y#0Kl8^l3Gt;+Bl*L1Fd*bnH`5W9lJd<0_Ii9&pWg$Z z+vJa(I~OPq!ZUpMc+)9nxx|%BQnf|{rffk;{D37`bAB=vKYB9NNtcyu{kj)vB{$8M zfCqBjY?_&LU#2QtWi+?FUp^>M(TZoz#wUTFKVCkfZJZ2?Wj2Yze27Z5|)HaJeP9+%Gw@&(Jm^1we{Vx{Z{P zx%1{dNsf`R8BK=_x{Y%ieVngUf%&1-{4gU5$paOsW*E3r+j|afUf#dKpyRVFpF<^! zAb0;d_0~svhc?h->sFIFO`+cHQwj9zx%H@Ka&E?C4q;Z$Fe`mhU0zgryB?=BEy3jc zG=e7rAD_3_SJ#6DV*Fd$HpwNKS3e!;^1ihgY&5_-lR!k~LJQpbYg9N#NR#OHN9(Yv z+1(x6ponTi{U_wU{BGnJAD=HNwFy*2qb}1sj~@MM{Mzf`@Zx#0uH;t(|0UlA%NSQ= zmR?vsWaH-d<3scen=g}5aiCyx5I!lGpOC;JoY1uR5DyTZ8i1kCK9nI@fRiTz{>v;5 z^7=l#Nf^7f|8$}hMpND8aL*@iOdj>UUAkmRNBa(bes4hyU(Z9flhzT{vE&`b#3LyD9cZuqr+3t3=DplmQ zoD=YO>+VnfqXp=<0+IL7iz{bSC*wI)LH*26$ONOS9XY93b|*BK%PajO+o;-A;QQ^=O1 z9A@W*=JE*j+O|f~d6MK$h-}OlJm^flNiX^^vZK9Z5Ff(76_v4;g7Ab%F@XezECEM$jNb8C6fcF4a4HluHEvX- z8uLYh9Uprbp5CiF(6NHD4RHh4dtWAUTcv<`61rg; zjq_7X`b(Ek_uV{8PiCB{*0LE+uE)kR2<97yv^0sN%ZHG^M`UFn=0O#1BD+EPJHW<3 zEU8!`4ay^&E;Qx-0T1~VAwUZQ9=LJaP73f&rCfQT6j$`^8E_#jx9ve#$A`bBUM8X? z5M`)KVfzkz1$DP*FXWI)QDO~uM+bo_abxvWNZ`fzP{SoUHu#qdzWy+5HKJH)I(gEA zjo&plmHzwkLJKjEctBHy8|wnz9Lqb(<2FZhIUWtcwC*u@o5^LAR={>r?U)tI(Fjw>Nl{JniztV^b`TRar6OmW0V=bT ztZqgNPUsBFJpX8%uwdSmQ$mWMOU$oq7(tzb>{ZNGg@4lH0s)M!_mo?l$YtNhKcNwp3zA+8fkW27{;?w~IgmP6GyfU-fnA zxxp%4;j5&~LX3Rl(}+gpkX4O;eDMU&8I7=jVU7_!mwRpB5Rc>ZadS21%E^1=(7Wp% zp3HCR9T5thrq62SUGy_)@~Q2%myUVoX3(SOJbr}(ibgs_O;rsHskUt>y2=W;h>K;3N*#DiL!7#-Q6`bgf z=&Q;>?AJmG5(MSwQojTN9YIBFND-bMEo1kR4Z#%)e@wjvM#p-OKD!4OpvsbH2TIHS zZ2X!qZs+||MO(~8BP2^^$l?$y>bbafOohEKj_FyX0611+Jggg?@(@T#9j37h#IPGf z;?UQZTgPk#CYmbQiJ>&37*DEbtrs=891Y3(ji1)E?<)~95nECZ+DtEmoL;Um z7I8do5#1pnEdlwpTo$k!+=+u&>-;LPw%>1+{s!8j8zBseX$vouiFV^AxKk8KT*WIL zOC%EOgX*Blq}p6W)nKwyhp+_;f^ixrg9Yb&%WOfI4XDHk7UFAR=boG3F7y<$V6UVY zi}d8sS!j3s9-PdRKk$z!!JGK(Q>RYFruG~5dmavk8d|}~oHNPw?7U3U;S;}6wrZOr zt*&ezytr3Uw?V_7RH5t($fI@!`DGwjW-O(JuAmOu4M|PFQsYq{FgX zR`q=z6UcyhF%wm2*iwBMQ^x`t<1se+_s|M6~Jj%3HUN0oGNUwaVZTPifF zL3v?Q44+g&)bhGUx+SpK$+cjxW>Me+fCQ5h><=6>biYu7cnf91dvB$hS6t4bxK*&N zt$0CrdYD>Apmf0E3gEy53_?&9GYJ5EH*DGrh-x;~LY|*shU+o(5bFXa1THgrcZ-H# zo!b5^B#SJgSsM+j1EjP<`uSoCspFCf6=83>`zGXwL3CA8j1k47(LEIeXF3IS|Ay5h ze#JevHbi2|N$EO2YDDLKjc#m&$CbPtUAb&qB%Oc`(mVsmM8whk67S$|L>O7X!Br70 z^o{nCrC8Tvaz^piJTv9fn@ULT$wyN!2NRU|bf5hUSK$aBA^#@6CwXiucclQ;)+ykZ zVw6K#0Ea3|1Sf|~dL1d4sGor`yfwVYJUs;R2X!v4=A{_I%OnkYKi`oXHi>zgXkIzic4Q;$>d{;J~-jsAI zOk_Qc53g0##}5V{=Z0%k1ajjKI2w$cYP7keWlN7PcA)o9g54{IbZ1GmoQhLFSy|jj z_-jGVrnatO*IJzpOY3Uer=_V^zC;t7v;L?lm%saik4%j4J?XUNw2KJyEkH%OZ`3BV6zZaOSvmgD(~}1O&Y+4)_rnE5_wK8Ih~rFYu>6@7Ho(> z_F&{_Sa1YXks7-CalbRarm~HNZ-`|YBlw?SNm{BWzX=aY>81PS!5ARsgq8-74@KH#87^3_QNGz>alaIeDi55FGRab z{3&{XOO#_K3qlMA*z~0q!}R^BhZij|(&E!~oZC{f<${1TW)}J?04lqVGGnXV$3Vfg z4fE}s*E!!?@LDkav$`!v4>LyEl#851W+ z1en%bCl4CYx(jfoKt=sJ9YP5~>l5Td;tK5I&gK?ut3@pIV?ZZND%&@dg9-_6!rvt( zPxUEF8!Eh>sVTmH21$}qQj>17ogiNsC)t+p`$C+L^YlwVee0!@29iA}cH_6)W&c_T zwZD9D8jpLJe?>F<@uV!N`^ZCbcH#Do@P>XHCP^%!53eL*yN%5vJ$Yy9aCz>Os?|$* zkYb^1Z<33uxqH(;Sy2bb7Bdzv1?rW3l^3-g`{SGcH->?cV4t8TBrfLVjA}TJ+&;v6 zkbZMOu5f$jPERCkp!yGE?u7~ph6%M_*Z`7V89Eu+aq7r6SUQ2F8m4V`+ zOtZ1OEL&oFM01C##+RxdFV*UW*7=2iijo4O#m?I4Mcc~WvX7^qp`4bX>XX0sY$k7t ziIl)Xi`Xc0(A+qoFVJnpfS1*oEnkEf&(wT9r_#$4GzWf9OoeSn4djD=@; z`|HECgM1C*#0V)T41#=JS=6>NAC#BbHbL5;p0Q+CC@naS%pTcKcq8GA?bdxWw{4Hoz}(kNWFQgUZ}QwVFWOQZa%>=@t6r zvP7CQdh$3sZ_m$Jvgx;fY$cSz^N{MSX;{mBHs|Cx26C`98U}>IFpalOa0mI;np^!v zkV~q)(lULdYSpG)g2pc;P_0D1=vgWQZCnKwJhlrUGO9bKBgfgUD5b!aj0r~U3zUkvxq3*J014>*#& z7MhRewP2EONzO4ytHrH!1q&G_l2yC_0E%yV(wvqw{jxv>01>=J0RJOxk$cpwTkc9z z*d?iMWF!{Pnq0h~7Q^HEl5UOzNXq|RqEDO!sOW&1uPs1gjjnt?nW4=ES;3%&(?y`u zqkd4Sq)m{NN~|hGAf*xtE;MQtDy5X%q>#n+p{o?x(UEJkJU-*9gD4jo`TERmfcuv; z!Y)4b@g}2GE(}61fQGoLYEoE1@vQB>O5n{(f5t9 z7y(25r6H`xJS1h@UaT!B;~2@=JLO*2<*B`rDj@Xq0R&_CrP3ZP zrq`)ny(Q0ua|@13j4&AyUmeVz*BJ@Crt49bOwi&BO}x`!f&{kY3FBxT#CV3^s%lhH zrk?Th+U7lQ=uig7lcWq=OxTEvmIa$cW}H;bi9mr}yw~z~NS3iov}XVG@P^lwx>&sw zUmg#eZUj(@k=8s|j^`WIxX7U?q^UsjWZiq@O4ZYfSA1hofT^X{3<` z5d{0PrRZ&-tTQN6S2h{HDb4SRy{1OAa}JafDvfww!lBz9W;JJl0L#3bfW7=xIxZf0 z$szF>ZncEjfl1r^PkEV(vyi;K-|wU>12~Ngy(HcPe2>pKuQjH03lCVBam^JLPk)!F zrgZ@rc_El$kk7)Q&i|q7&Es;;`}Y6SzAxEj5|s!^k|iY)$ubmKvPAZ5g9$armR(J@ z#!d;@vy83mY3x(VF4UNaK`J}_p2x}kyT5;Yzt`h_T=#X&MV;s8^M1dU<2YW&%fuw2 zo1WkTTfb93N$)7LC>}Rn4TCj*puu*o3^ve(U>~6E+wgj1S5Aad#z*=y1T1%4rEXE+ zflzeXVJN{4OWlcql&B>^o7FDyc$Su(XahtE+=xum9fXCkBQ-4)U10a;m@*)!RaRDy zc&5uZl=fGS5S)J{a`ZNFmdOri+(L!y>4YAgxVhW=4Zk}gidK}+hXOKzGaJGjxxyw{ z;O>is?p`>I14TaOzse;UZiMo8j#g1qw=u$yc{`{GH@`NJkNgI}&(Rr5vmo>t48#ar zxRboSs0pkxQDJFW0U%8A?*iE;r`zoM^1`p+oM6WvRN%mOJu5IneU=1|uAR_bl1Suv z^lohu-?WIj$&mBPpfD`eIScZaC%REAOqtrZGF2P^dQrZQHlS0RO1OkNN@&lV`uAKo;ien&1`_Cn9P8yR&J3>|s16I~_4q!vIHY>Ve@UoB;NXGqzikeh5ltCa_ zbwckZnxE?2oKviKH|yKSQF6)PUoubpF)<#Oc_f%btUsX6kMDAL;-lJ}#*0k$6ehHM zmk&9q5-SApPJON^5R65}-~Y2}8}Hq}q8*bB6yTXQn$0d$%_FYD%>GTogESx7C()o8$ZhdA=75PZBtXicOa~xv^Nml67C4xom7pP@o*v;$>PJyMNgF3*=Y8=X#b3M1Sh$4gAud0pC`*&>HVfBWgM*&(I zGAF`abuZw6(0h#0lEAUzaFs*VG3e#!-aWYJt?;*&IDoIL?}+4St|VC!u$um)m(*FN zCm9wUn$#zmU)oweZBoilBH@Vc}87}}kL1b$9 z^8U9h^hZ({iVv6DG)j5e+Si>c7A;z=*idedMl4ZFyutFk79EGb2LN|KQ!=lk1G~1) z2&_lQ{jJln2o`qg{0b}+CJD*u`?7Phy4+9c10{u0806Im&}qx!pKlwj)~+B1LC;H? zp_?Hsr!iP8HN_A3EYDx|Pr$9ika=@_*1(za42tR*bi)&x$s9}-bw#hg9c{%k5}LrX z;h7Wx%8avI+z<;|D(IAr8))L1Vr+JGo#WDzPk-+Q+fzk{k))|*nJAJ#mO6P8<>_EE z=q7Xsc&OK7BFW`1)xwm0NN@)9N)jZDjBN1BR<=I}2Rmtd4(pZVRSU{oz0C@|bQ^*` z6$gXez=l)7gb2BKI>*vlTxtwTLk4_IO`KKX)!wUzik;vVZUKZfV*bIS-ujoQ6Ls`9 zf_cGzTJnu!CbPNKo&xmLXg<0krP42e2YvePj0KPZ=D~KNB&f1%+a)#A7#r)W755Vp zLqknhcv1|jG%Wb`xYQVus#CZeB zXoLjPiJ`cK{67v~dS{D>Avk(y!95w)*s)k9U^P`4?H&Q$D{Ce&nmngaRc;%8Z2)dq zVh`WF?2o&`!L+ImnRFZR_^N5t$Z^p1S{sk`Tgh943f2-KbhAN8wKr}+$E^Zsgragw z|3;ZecQTB}r)`2NqtWdg=-J_#OcrHM1Hj<8)UEs2X!1y#HYcrXLg`i2)Ev{$_M9Ik zsajq-Mj|e^m_~kNHwHnFHgPJykBHuE%spWJRu!puq%`4ho$P3r6ALs=9Zr8GH3<}f z#1Z5Spt$n7E}%z?%~n3!t5C^3xxhbby>za@z)aFvA{MT#WjN3htBaFLsH(u&8X$$y z=<;$!$Ka>o)D0tJXc3jiU>11t5B!h*JL^=1Yjj6E(K#9grMA*ao(&r|9E+~(*p-AR zRhCxMLSQeZb6&*23kO3Js&Fwzi=}6K75)lq8@*zm>N2C=r+FEEn*IsDe2LiY^XF-j z%e~^R8;z}xjO|NvU`f^|skP^#P({mOn`EKyYJQi<1R{ea@8{FqTl|YQ5Diah5Jxpe zXjB-NN{QM*LC)Z6K}sg0r!juv`87w8ic==BPlS5mg^R>Nq;981nwSPa=rm)?;1*FXTqLk`q3H&Iy z5BD56urc&iSILxUGEfmdZCN`6t1V4LNRaB+YA_S&U||4@`@@Hw;LjO~hJ+M2y#{V712%0}#cy!n3}4@Mc;tP#>|f6CgvKK< z{d7?7c0)UaU9SgZ%?iGjRpzMO$$z>8VzV1j|2h@-_se5$FjHW=XnvH^}P=Zj6m(w^$jvwaRUZ)21aTubop6(PpA)(?%7nD5 zxlq3OPjc}@oER8?>eRPJNx}EtKlRC?o;p2#20i}iysxA7)ABARtdNS>f|naQtX$c$ z1_M2(-He~toPLkjX|&YIHHf_VLZ{2%xfl-6uB}~Vsx_|IChVDnUKDzeP-4koo~yM< z8L*oU3us+~!USI6#j|*Nime5L*Ndg$!0&kHC9-~b!|y9s-n7cJp;(4X=V3FL6Z9na zM)jWQzs?vuIGqpf6ZiFbjs1=C;x7|sFs&K8Kb8+b%+grgv11=XhcOjtFfidb(ecka zC$Ej5W~54s8d-Z!&qU)|l@26ANQSbm)Sv3Tf;EX+iJtS}v(h7YkxUzl|l;8!#xG!eT0NO}IDTknCGc+ttox<2FAJe{`kr+vWrCUc%EyyZroKeq#Fnr z)UpR+CceclG{-X_qwO}1e|s>qa-~X5(P~6CSsvU4!bJuvX;|=#hh$?gt;e;+v40>4^FfcT@ul4#TW=X6GKS~bKWNxt|)JPD}@Y;Vb+Oj zc|u@0N5yDIYD{=HogQH*D7@P*zZ__a?xE0ZL%Tm(PTZuv=J{CV7wR>j#CbHsb;UH3 ziK4K>Wy_RbkIBN{#EK+*J^f^y_P}*7Nc%cr)!iFkNH(T zHB{0R9KZbYm&w{qp_R3b>(}U?E&6A^e7OujTKoix@4cg2 zH@3AEtPH)lc+C?Zq8yO(Qsf(P(amF}7GYxMq9jo~B_zl=E!2u^4=mi{^KAiXsB#he zo2Jo9sQQP6SI^$8|ISP3XDG7p>s}6dEQ2lKQRq$P!y-@%#r5ovXG-17oxw<;BN|1y zatXwRFQsdon3qGFD&ZvZU#Hiu>>noC0!)m{E8E*u@&(3>mW`K%HBRK zA(c1-^UkwqW84Qd{QGxu@Bv6^fUy$1zlHeS+=F97{vIzXLvxkA+Kcj_%!|vRKtDsh5G)UJ6Fr4}8O3Uj-Gk^-T84e9x|3J79{I_Y--T-*_snBI|;`{JfTXDc>??tu&?xggkcV{g{!O zw1xW+uZU;!^>eL=E(4S5{wV?i$xmC0yAI}k6bI|QbwKy z9@7tkjF31lpheVCqD3gZQ_JfME|DM(6)dABj;Q8K2b`B;v25$sq0!f-2W1l<)jcyL zs$ShIx|3t}bgNT@QFSv~1tAy!X%=3*{bhsb{(6~C!ZUiTBqFUE2CC#+FMeuYQNRm= zhbq;oMQz*Wes9PjQY4**!2kyYwRG!aKcw801ALA#zn|+!fJIrv>fX7$96-?j%>8l) z{g~9&ayZC!7EIgYdMPJnf>qRTi{O=DS=CG1-MF!Y&CYJ)$M4PCFluSj{lTyP-dY4~ zvSa+A6Og|-a!%wJabc4%2m+?JW6-Q9b0Z&apZ*pKrYWNaRHwPXT?A^`H@H3v{H$nzP{ota!@ymWcxg^*{bmZCK0 zXUu&1Q3D54r%DsT8R+=&$qTSlp>^t!Au9y+Fheu0TDPd+{wDu^%;MKYZ{OZ2`1m^77GXbGof0$|pWqF#~~M&_;_T;Ic&B68M7vcxnKXR-XSo6lP|2!MiQfPjsIO z=0Ywue3{mQ72Jimw^%>a-?(-qFPsU9F<#Hma4?C<1dq-Dt9${wwMmVfK;bHd6+Q1C z%|?`FUB!HWbI(z4nul^!Fv1v08!tcsiyb8dX63e0ICWn$&v$c6$E@x@|BMQ1SKinf z(~tfeZ`+^ExTgxf{U(VUBBBp358Yt?{K4&N3p}T4(w=sI0q>eYwAs{oOHNf;Lz>!Z zEOzTzTU#(INrKkuEADC`1EHf6EHRL2y_vk{lcTTIz>-MIIH}4o#_GJ8lu6%L1dxSk zxh;Hfi5xQW;S5eeLb<6SMMDb)ZNy%Sngm7zR}TN<&_O|449S(c2rqRnaW*U zI1tJWYz>PH7;t}N?s-o{F478VHUxG_!5r1tVb+IIAc&9WLx-+i+kf8jOSVU!Z$ZP^d|}C00WY^N8LYgH8TO*U&9kP0S%vRQpS4 zSI*zPyS5_|$be+2B??jalYa}5-09mW9*d**rFGS~EER70p5K0UW{Z|~zi6``%3rU3 z{RB(W^vO07{ao$?CB_v2>4eW&D-R(y2`8S@6-?-8utU8NojFVn@Qcgxk zR0|^ICE622n&Z0{GeNgQvh>IQv}{pn=8328s4L$5bE)!#;}5&UwYKAI z315TH)(|h1i-wZK3Q(+VNKF0mQVmT3hey|zVj4@EQhZtvrt@G$2)rw`*?yJn5Q)@WN=9rp6^Fq&hPj@H zxK4mM$ituO%q|1hrOy|S)|bkX+UPOZp}`;xFq+KF3aj#azuz=SJXLQ*!o_vs$AxoxeQHRBq16m;h9QC{mR^IPSuPCqYq{o>_+TEsy<#|H%3 z+2^o+{}DBpFn)r}D7h_B>(J|=Q$s6$MoJ{4SbQt=gFY{XGByKcw5VB)Lj$-kouRgc z()M9UQ*Y{?k+D+6urG+paXCco478P+{pA29hTRHqzF+-cp8-CHTH86+2L_;KI&ruT z%j1?Z;#kPQv=c03BjEuUVYj0r!=xp$T3Qm@8!D(;mmSZHx&P*9ozpjw*qrL z#^lPyiwnATr;N%re#BLzLLvE_C`7b!ggalmRJmFVDd1N2%?TV#+|i*c;xZ6pDNFsW9ZJBnXz|Gp zu_A5%&iBg1-=%+bIB>uQ(?7haTbl(G0_H)mQ${QxacK&RjHGSMV&#jbpgD}cI z9xK~loo5QlK~*M;(JAq3)>K0-z>5myFS>yfi+yL!7udkzt?}EpkK9;u?u{l9wsv+N zpkH}`Q0~;w8t0e)5wtu3htr#K8;}y>eP3?iUZjGgpfPivfApYIZ`Cz|tTu!_C`pn{VUP z=;DP7+tOZl?v%HWKrYjFX1c&DJG(Y%*l;sOlbagFQ-96~;hDgEzWP<+kaIilI z4r_6A7>wiOoBK^9BFIwQaOT1Vd1V!RSa)!X&8tSteUc3%IwI<(KE55YR#73)c-xF0 zCRgGgRzpQKMYN{|g+cid^9J9i)u8XS-QF*^_pnEO39p(!0Pg6rw8QI+kEfd2t*@Hf zSz&~&M zApYQ`QF_BxFXGV+!4C=4abNBblLdNYi_(ij#92rts<9v%!6-0pG_6^>Ll91SI>NU2 zyJwP%ecGc6ytnZK1T! zG+0DP9ZE5na$_c<8ucU^BGLDenc&?+^~La&EX*kKr^34s63gWs2XisQqWhlYSo{hC#;R;~3d!(4FrblQLI>Q#e*5L7Vz z%l0?TCw9H>g$96s4X>q#4}S`w(I+~5C9BmXO=Tj0Z%U%ullu{jQjH}zBzhXVyu(`0 zVR%eAXg6>G!(GcWT|>gvqs*pz32~m)Yx=s=Teh@Y^*@g?V?s}N3kFDcIh@=U$1jrn zg&!oPkEZy6I=haFmxL3aI-)PRaAB1H%~@S5{`RG1(5FW`ZGJ1G>uq8(X=J&Gl3b1) zPCzGf4;nygYip41c0ffWNm*)u%{;d!J#=FBo+7H?+($`WHKPx#*Xc@wcOUlWBI4px z;0@dJ|Nn@_w~aWU1KoYm_M;ElV^dHvBqW4jY?KY|*;CY@ku43J$ZvwKnI|G#O3EY# zvF8cy$zE1HE-7Rqa$k`%p>17_am0POvb6~t)~6FBt-gT{X9 z*Y7*(Wu#edT3^3H2EM_YhtnPvG5{0TAKzf$qnxAT?!G-Y(&{jf}uzI1n4_KP>JPCjj7wzSD z;=bRVVnet)R?wd$^b6RYH4V-ijS9~J_)O52ro3=AQm>?b9vKLPp28qi1YtU5iXJ-V zg$TW=Lpm>Q)x*5UBZsC)O@BBP-_6lua{RfE&a+_uXaukw-d#`z(Hj%tw|>)aCH1NPn%S zZtF9V46k7~S?e+l`Dgom{fYCy>XIzBZv8Q)*hVJrI1F8Gcrl&5Z{Mq~k$x@(Oz`n9 z+cLUaOTh`Kq3ogffa*LBZwxP~;j#nc?lu!7%Lsq_mEnGa2YxD)xG0JIPW;mW_r;P%k-8yX%UJvuissE@o#I$cb2!f`enc+Eiv(@ z6GC6mbbq64=RskhN}==_&s*PkcQYt$3hhm+BFj2kQS36(uelN+3fW2muNVscJI;D* zE0;cuN`cv?+~yL>eV#gvHks+JYYVb?OvX%G6O=lf(_+!GWp#?>P?iRuAwA5VA>AAT zmw;8sd^E2AWZ$=HP13ya?RCb8jvKSq*E{6d%>Y?dG zNsW3geTIw6pihopU*0~%F;r*+gor{Ety25P*qGaZ0VfxK%Okw|R#&CHiW;Ep*Sua_ z3RztI;TqC*luh&52*(9ADlA3%%~}k;FvYV+kzGAj{v#j^ATc-$BnlbN;FGIcuea(o zMYTDEw?I0n*<}n#bxJhtvb1)OGIh9z^4i8Q!@{BKN@`k!PG6mFHkrBMf3yG{V?YTk zspPon1_QK^l*E7*A|(KK29A1ORZ*yxK6F12Cuy=Kp8i^mpPb0{=^x#~BD1}Bwckk* zNyq~fp6)0>SKX<5`s|KdX9X6-e4gipHqo~l^V=vL7|<1I!G9_QIy=T*esn)*v2`;o zKXQqsbz^(f8NE0ZR?hGXG&<8U8C_YT3U7Zr!`kYdbO#q9?11sG!ncBTvHM4RvLS|iR4s31i(FK zkW(>gQh(~WV2^Ptx^<7m?UUwK? zY&KPw=xd{?r6ieaDcrprR)OC!OIwbrQdka5h@2T@S3*JZa(a|_YEU`NKLh8`&uH+` zd}f{rq3`{<9CTRH|8cdI7Wn?CY}%e-YWnX}Gk-IAHQV(5$>yGYyuIB3xYO@g-365$ z`Dt0tOc^|XpA0v54tiUZ76VZJ0_@aKMMLMc(hl;x#8<&hX#7rI1+=az9$$LmN0s*z z$8}vC^&RNYS@;URF%j3MNR;eO$0?`?iER;-g=cm-=iyTTX_;8xB zPDx`asH1tdz+!sjP36J0AiiqA9_vde-HlsXuRj}~hUAeHsB^Ei*9?*>PD0+eLA57_ z-5!T33XR7TU_EI*Nvcg}e)?5-%9U-zg>Mx&zqWWn*@LDFZ_^YNL7dX61S1uTiEaL@ z3k&@7*YRQU*~CKvPD++{)T)Nryz}!QcW8@0dfaaZ^CYiSF$Z*4RPef|TEVelUk|(K zzNta8re1d)vtk^o39J`b3yMbm?3PE|9qAzBw zXBp-*L(j}EWE4YIs;ZCv_s#8*GWLP1MnrEg;CeKVg~C4&T2Pj?;}1}sE|<3ysJ|dA z@zqj9g5bzQK=Lw8ch#_u@>7KH%$IGgIJq3kcBh|O^=$aN($pEPPo-6hUxMCB*P z2$`X2R2|%y+`tRcej=`i9QUEfWi|Sp)<}OAx&bl_)=b(?N`!MrB9Uj$COMK`DxlW^ zW-#jNX){n2AzC9uZ6Sv*U-#c#_@=Gkqk<@zJJ2p@r8fGnF)PZZzI7bF@*iUco&1%* zGlcKK*kd7v!w#?>tOldpX1jfy5L^Qn&!gBK^5k5og4%EQ*m1I3U}U4-D6@IWbwR9n zh}Zx)SE^ij5^7;0LYMHdfO2SD)iD0xI1sf0F}CNq0$G$YAoE`}Yapl~!Pd#Vdey4x z=(x;W@RcosXj|MxHJPG}RTTvWDUom#eZL=x3^Ev1c-1QQR%ZOE}p>Q1Q` z333<0(z3Zw2wjHB_W^f24zh0MccZwP1c04kq+=<J#;rnF#ksEFjK=tBMOA3MZ|El3~M zh;vzTv|;1MS_KuJwgwMEi!YJ&W1K~Ro`y&k&VpS6=sM>L$+_Rgto*0%_z~$T>#Q~d z&+-$PDo#Xqw~Sd2ydE~K1jz&Id;%DXrlGd<0YdJI|jGL`#EwD(8dL z;8e#-X7cT=+{Tf5SDTPe6gx&6p{>Oz|6nxS@FrLuWxw94R*f3X`<U6FQQ@T2ZM?XYqXTXHJU9vK12+FmOwAM$*Q8bfxI5)dHm88i3f z_}1Um9*u(IiW|6(2pnaazJWnR`cR`DIY8ro5m)gDFDpSP3KR0q-oaS|@w4H_Yrq?g z%+;@%37i=u40jHVs^Eq^bMM}ATs|P*5(Ka6ZE8ncWwDfO7Pu$eRcqU9z}%S_A$tdh zkx6+9L+}bm8Al8{M;}D(OzUtFVQt*d^TlyR?sB2c*iFM@`xP-THb&)>s4M>Zwfq@b zmI%gaa%me6KZ8M&c1$!T)XKNU9g`tYQgbV$==dn!`^)B0cT{!|+q&-$FmuP4RCh-@ zb^gUngkz)p@hkR3N6!Q3ldzUD%Rgzt)Zu&i#q_xHkm9c&TUnjS$X0qZ-Kdt_fcE8z zM7+5DIiCJjAdjZTzN-fwEV3y$zN7o%3T968dCUJh8S+mvo2cRkNkO9BwKf3+>O$Df z#+UqgA82yJso3%OJXG?10c6x9$43>uoblVS^wrVOB^HtX$LDt%Z{?LTI$}keL-y~? zhSi!HSEknbD-##kM_%jPX;GiajjZa8e6{4VZPdwE@11b9{Tw*!`niF-dPLsN&1n_x zwE0HXjP(6C7GDd>{}>N=k-GCuL4bR2yXP-n$W%}^)1U&IKL!H3Xa)z3me@8B7~gIm z-y)RL{v}zEqLbB_H*6X;l+mn)iTy|?3$J@sTF@Q3^Q9~ue7FqesP)EWEkSR-a-k$aBR+j4&9Y%oBka+Sx_+w?S{(QjscRm?rh zBIk{Nd$|!6YdcP2%EJ?z9M6YbVxy4iSJDRr>sC@W=;t{=L%%m>GuleeEx7@I$El|D zRo6>m;5!btcaB~+nn;)1FQ|gFT@**=T{xw8u#MSmhNnpeJXS>xP2t&$Ihkm)Vdt)0 zS2~$`&8uu~Zf97;PxLi!RIgq~c4Yia&{zU=BnF@Pr9|lIMutUP`iA32(MWJe8Iazm z)s&PTtU6wdcGBj*+c$6aGE^i-W$@dh0M@9(N+EyLNOR11;H^QddZ@!9ISVeVJB+>b z2}KQ)&};|v-|R?Hw0HEw6Gu`G0_H7(7m=+zmRJp8eG=*TLa|Gd;|ob{*V$?BFOfAa zPz1ghF5jCIco;9rK7t?|DQ6S7TufFm$0|iQT-Ug?1XSI~HQz#t=5CyuksY$cA zsP!xq4ru_lg>_1;^M&xreg~ZVd#8TtM>wixaBtVH-H|}-Q@mC=`rQBTPF#mE>**wu zF{TmE#?z^KW%uQEJgk`i5)u-M8R*-#_QTVyP0qzy6MNTs1OySgCn&vac%!l4S5}5a zP-l&7dw6>C)l6xW_W6e017SHBaF=4&)M;?>j_&#E*qtEp7rAyQ<=c&XUzS5~1cnif z`yC!_B4QMf%D0Pe8y#lC4C!2`x~O}ei3ZMkwEb8VW@y^*i{jB> zK-Qji%glLtMKqXw?oHrucezi&F$7_ll#kG2yZ@7Zsml%9#*GbM9L5B#hHHMzo7Er} zEz;g&c{UVMB-@>9@`D_l8*=UmC}{rwNSRDD#L}@C1^(`pttSwwCoxDA(`Ftmv*WLL zX6;O`#RQ?g22BO{S>|y+S1NJMkP(Rih-Yn`*||HGgJ6XhAZ8)a=4;slzk~bTf!1Ai zyI^r$(C4NTpFwK+><#b5tT5I%=!o2U^mrY5boU9%2btg6lFAym>|cisT4bX&dk3AY z#^{sQw$QB>g)^fLbN9L)KW;(DYZkR*UB+N?Z@UfuNPe$()CldUHXgcKqo^JU}&N%{E6 zlR1C{pmy%rf4Jw1Mqvc2--}EwSUz(`lZ;G$g*^EWyw&h!%GAqCF|Sjqr#siWbqdFl zby3QNB5aMj*i3&54>r&j!OHz|76@XNxMR(5>g955cDD$Sn*Ysx z7ReI$N|r4vFqU~jIxG+#H3mqbZbcDD; zbQN=~%JYtrlh99f0uVxh7zc1#vTjpYje!1s*5@_B1|g^!R;H}#$Qc5Jf83n|g|xN| zffoJVyK_l7jadl8ZZHmt*KVU~we_X#EvzxL0E&tt(lW98KIWYz9@EsYwuVI{pv6Qm zQ|!$LCItK74e!UJC~Y9P{49g+F4My62E5dQS8#w{^@oiZIdX}}Pa>ZrFeo2o_+-oa zuuUg60;BWvD)Y8{#u0xl4GmnRJE}W>=btkO5^g2yVieMV6_74D@QS5LVL6u@?UzN2 zI9e8#ZEkZO=4$gF?Mv1rL>YaFWEIQ=0IAGYt64j;T5S30qv2E7wpDlKB^LC}*tm=x z6TSNmcYE_?xFB`96zcPC&r$9+%NW?K=9UQlT7t>C%$*B}C!YWV&m??X~7MX6tnX4|* z1q;}q*ek_mhg>#CtE4%hkZ&LB`~Eque+QcvJLsDLPKI)Rq)>tBlPOE7%GUBU@=mhc zRaLBrIt9!fI~7cekJV664z>GZWEqGQqEjbvegoKrZV~W15=2A}6+~cy-p=l3{afr; z>C@mzJ2KHmDXJ%Yt7pom|ETCBDudV6tTUrss?v1y_#`o59=(TA>-`OK$D%b$PA!SW z+aoIS7oKl?{;dJBX{$1&kYca3V(-}{Y>`2Dr3?c(`#$DdNhd+hBotLqU7W2G}d@_qm) zB(lj1sFrM&YrCgzxyI5F(BDLAU37o>DW9dtkuyD4+h0~=_QN`r+cvHr{Vp}ZB1AEu>3 z2GoI6LSmNI^7+itbr0Zmslru`ks!n@ssL?I>_TE+F z?q<6^Phy_g_VY^zEicnrLKMtmQ!eGd+$#4Z&m4fyE{rBm zpabU(kCoohpC>+(8UXQJA?BgZQw`;?hHxmOp^U`MrqtI}#P>I_TU7nY9Cu1%ftJ!( ziEm*HlGjo<@UV4#dwUbm2CWKYoRLp42dPJB$8y}o*1C(yT6NA5%z-D>kg(&4iF6AT z&T_3);m@@3(Ex~GvrhiHhE21Ls& z0f3b?j2PhR)%617JH38ze2Uf~U?CxE4Z`eWx>ZcsPNydGrmW6h*}^Bwp(E$-{=ybR ztV7a1e1mc@f*p#&=wPP5cvK*t5mAHSZPXY=;mVBmeW&RC9Q_h7fVI1o|HVt~Gt75%loz9?KuxH4cxk4#j=B=BVZJC#@rp|B+@F zf7l$5brrLzlJ~BjWV)U{4FQ$EqBH&stQ-TeCv!v|cWBoaYNUQVzz zSA~YINnm{O9egzYf&?2N^9zX^OnPX7p1q*IJ864B0!w}tnZ^jKBNM90B(;nku?z## zCwq^kyYVskzg5C~hJhcZ zN(r>(NHh7!GwT;lHj%;OAI?FO_b$76=OHfh#36x0a$n>)4Z~4Z@rI*MGTs)}d7G9> z@g-%2MJMLor%yF;cbHjgF&RHg)my54Jqi%<7YtpfY!_94)RA`N4F-;~x-jNDdxd{T zh5ym3SFJk38wP2kC3oL@ZBCu}XBaott|-X|FubzN8Zf;SHJXI)6hOax{S-*4AZd|4 zAZ{$%!aTNVk%$Ub%5AMJ(o7fIBt_`S8|vA!MQvw(O7$H&&>WeZhT!CP3oHl!q-qO! z;Ca3UPbECudy0ro`Hq*psCFXpHJ(2BL;I~-4$-s7Cs0`N_S7fpyMv_YK z5{chwk7F%eBYDnR5P|pa+zb=wWrQq;$K9>O!|t`JH;UuN`*@CnD=LEK>9)v|L`vvd z6XU&h58KFKIOg&5F+<|$mOxA6YqmeOqT6GVu^cdj1k!)$%%`WPOR6Mqvq1N#B$~D} z^p)~{O}x#dG@GT^Z+eymmLLVPz@bl2Gs!uL#%hGk5>;8>_oDek&N|siKEQ-$!BNb! zif9E;mvY+xd+bxCht@A6Rt_3dnd?&yyLb2Hn<^I8eiAVpp#Eu>|BE+Yja-VE65~2i z;tETI{?g}Muxg80ECX7z54Xo zet19SvCV2vo&!c@mF>pR8SNUOknO2;Qe*|4HDl8-9RZAzDxZA;a%C|rME}_QN$XA7 zVInCt0wt*qft%%2#X7smll=pJr_RwzRNj3Zz8nw@JDh!1H4I>+ zz-idE(ten~zm_~vhWQgPHu%Ma^{(1diyTl^{~aGR1)a}%%*Ot=VA4;ky;L8?1`$3U z7#=WxM7}|z%r~kK~X3qTTWVZR+ zY2v=5`1H{iXs5Qam_v&$z`rP-NA=%HW8J(fP5lV>X7FF^NNBA{faF zk3+QgW=`x0f{G>t^MN`6a-GMN}XX$*Gm0Q;??>6$6muvZF;AUAKtxRS&f8Fv(Zr zxI&nKaQ(6}`}Xdw=>knZDhfJ|z4gn%`@!4k=H-z{g(`y{7R2K$TwD&rHlA5`RdB^kx#5h3r!}k7~;}VDU55p*;7l$$2v?u^)&V;9JJa}AQQB0 z1Ajt;H%!}3z*^qCI{DfkLK0EH3a4sm6*mRal(@SWT;$+Av*(A%#)*?slQE`9r}Bn6 z6g=Rs3+Q=>!=a>$&Sr}P`XN98Kb}kaegcpHG&PSuKwRK&7Y3A<4DY))Wk5}GWmJ8m z6$3kKq!}QMdM6b!JfH$%{#a3lsXsYd##(yWnz+e8U$gi6`EcHv+2?{U$=FVN3kw|K z)X;dYo9fW?K#5<9-=`je9w`6cux|fH4ge+_hD0;I@vc(zblP4o*K7z8u~R^>P(VJb zTGGDZOcVM2$0k@Af2>M-CXTnFd)r+Z_zUbKTW@6uk&Rumz#caoPkC8JWGx_FWcB?|3d zx!7S5^VQ5Vi?C!3&k^i>CE07Ph zdIDn9WAK+_!rb%S(N7^J)nld3l6;AD-gi|?Xgw?)>wrndgc-H*3YB?RnMaT?ibhZx zAyz7`bn#1887q2ySped`JDy4PMkq08`b!B~fq~NRj4vugNi0*^1O$5F~=kqH{ zjfypi|9burddjweuFBVY_RPp`f#ABw*NJOrF#%eu+<;;rEnuO|=Bn-6tqsC=L8^MV zHs!Dr8Q1m(flovDy zL)dmyYACElcLR_x*}b~$)s|BsrI^)gPg5g3DX|Pd9DM_Pj0R@D*E&rgU{vKZ6{G)Y z=gyLR0}L&^s@U~tILvfc((2X#%CfN3zGgTtR<-vV1(U@~B|x{M^%VF$9!6jM7W|{Q z&%ggZFu41_7+PBu)5*JGgD#AKaFIS<3r}J*os&s~+Ab%53QAZE`RAoZ?3^Q~Gdj&G zQ__V%QOzU!mqys2 zPN;vFyf4EiWh=FF-0zTnJ*${P3IqQ5G;B@z3Y49HA>W6Bd{gj-@K;%$q=16lgob>7 z=a9T*n>=n9cHO%X{i00i(%R?VZw(KTR}I|I@ZEZ9L|VhdPyE|IPoKKjhZ9Sp&cp^g ze|kWXNv*^(kGPcElx42@tvJ`FtfqH&w;LkwH7r!+EeL+cv%uHX6hcUouGomUCiV53 znb@_)v*RO>>w;o)TU7mODwk$J=l{F6p*vj;yFTyxUIS}Y`AGf!W3-5H*kR3Q=CGS|5HR)O@&Sr+aqw@Qfq`fEn^_|z8fPG+fi0e$anUb5u! zu&x`ZVxzdqa+##`%-GGZb@$+<=83miG#I^SYXlu|3yX1J-+gc5xfhk|7FADz$@Mwx z9zo9-s$1z)&2fm&lytx86lwb?K0wOwBOB? zlvV$ZOul^^MbX{Lu79|mhzBz+2wG6u(V1wpB&rEoS_HOTZfL!HvB3b>kR;UFTc;-| z4h7}D-j5{$pSv|xvXyfe#!r_hsw8ZoNYOAG)WiisN=#Vp=IfhWmNGY92hpvH&yy!l zaug%PeX$8Ord2M~ad9rp=;WwkbY=@FPtLQ)5hiHK+o!ZcOOklkbPUmVHgmImj|3ER za5z+d*7%1f9KnU_Ipc`Wu`(Y}yzQraFfGNW_=|u2RTB2EZ*cFgK`&`4vWi)PKMSXP zR!>!c03NP|0DVuhELTKsLm@YWUrV2Xh05(KCw;xnucBZ2z+N6^39$w_t6~V>CkTn? z?9H_ZFPdqDngp{O@Lw|K{e#!Jt=N6ypC&dovG+3h_OfxxXx0Xbhgw52E-1>JBg|8Z z;V!7vmE$^JalWfB*-Z^sW`W>ynnEFPX>AobUU^KRG##8E`I+);-~OC1TBJd*s)N0ay3 zq0ljU`pGtsRp5Z`Hy*uf;l+<6&m7Kp8-qxwQQO|Ypj)UosSUJjoeg)>06pK7tr=Ba zP9FT3Ot1_oKot={(PcPHCe!Li?F#0}ooAIeHIA{UXh8*TZ~RDB--prELTui=Id#&e zE6}Mj@uJm#0~R(1^dJ}BzM zN7&O~vi7oZfjcn0$U_k{1scr~hR?;P6vyT_K^=g*<1-p|t@WsNb^iHqEhYk!&|)d7 zq6{3W|8d{H+?|l3Y>scOf+64}SxUnVl5ISGY=Bz=!oU6E{@;}y>$#OgLOjT8=O!vT zA}t@As-+mokD{Wm=7H9)?`p=>UO){MfTn*knybw*GNmVMaq%ArP>__BnLS30vDS)A zjd)f}GsI{{K>#`K?EudpttwFBNxp>A7F2gZH|v#DYcA1;#B-9i1a~A!%i}*~ z?^eN%w+7AvX9g^;Y~om05i{VAiiP1Q+av!}$N`|~YWDoNa5(B)A(`?#ehdoTHbJ0UjR+9=|=raqoEyUD77TG#F_&IKCvHqCP3`4nnF0 zfHCSCo)x1Z$v#fIZNOM4S5C zyO(1QM6SQU3RiR<@rl!1^gn`x2v5@@_1*hVm8RyShlv6MhDD1C#w@D_lo-kj1HVao zk@())fQBNFturf~uy=O}U6NXe^tzi|=r1;#bxhn4Uhp{~_f+ulpI@D%A1;n`jbvIk zaF6wKRFrg;?u>%Gfzp-Txzx7Y^EZ@`hjzw}V7?S0ZeBO*vArvwXt5yk-tj3rGHOsW zRJ~H`d|U$O(pF@L^uwfYF;7HMAPh7!<-4wFOx3l|_~1)TA6d@C%XYwzLYWuY^1}ds zbHw)ukr}MDCxevW@5Nd=mg2*yP0^H8D<>y^3WXYNXS9MZjS0JDmH#YR6U#)THBMcY z2b4{EO6^R|%NT6~+mHuw2({%_Er^OP&F{8Xy(wt^G*XIwcs^^qxNh?KC--}rVOLxG ztb@+vU3_yC1eURV7r>RsZZofVxpSg1epo_8cUqp&zr_*pF)EW0+rUmQ0J~RlLU-PM z`_5!2T_Y&le);be3$tHp^6`P$4FY$eH56hX8*((?(yWLRp{_Xd=t(7$G;`gG>@%c; zWae1_*&RRJyq=$*FSVRH3hk#s3yZX}LExTFqxg?}h&BQY1%%U|@c$y6s(D3k1qMU) zn!(-h_J{y0D5NPpQVBov38Q48cuSR;jy!5E+008qFR9v46WLG7xX>wQ{R4P44T$J* zgUw5NNO9T4Y`0gx6TjNfArTDbFap`~!JHIt+(c&T>nmZRtuax)dVJ%t+?<8uB zx5`XuCV0AtN+FNC0!G3fX*d{^VUkysGE?J{lD{p;7Ss}Hi>o+`0z?&r6Slim`$8;<7!nsE`S zj}=!tkyKRW{^0oOUbHqPS<1s^-#YUv z%ASa{vy>92_x+<(G2j}nD<{3n%d29Tj}#4H$MIn|M8s2#mnjSf-^%{?(Is9zYZIviH zv7zZkm$aDc*XY03K}iMgC%NpV)R#J4;~tXW4IaD+#JDPxD0>Zc@TBhlUyX$L_zOr_ zZ0UIClkN?5fO)tEJ47r{eQIK7*Mq8L5jm-=Stv-jFgdF^6rg3$k!W3FY;@`| zs@T%_w~Jc=9&8l2p?KomyZynmx|(Gk@4l|Nr=cRCY+v6^D^{?}tNHwm8#kuB1p~Ed zd*I5`$@a8|IgoU&Qy<;%y#=%MIPOIUH@6FbPP=T)U1!Bp-^d)UAaHt`^QW_}ZQ2ZA zB6=~-Y4kO{8;pM+|N2UZ*_G(~yo?66@7W$=s1kF1>9T^T5!VR+#SG{fdX9g{ZkyTz zZgChIj+dKqp>`kxZexN7?C!jQRck(e_`s_K-R*J(Y|M_&8E|+{?DF@=>#`VdkD(5{ zT*JUBKwnF7lr!;^W3ybuL``tWVlz{B!d5;8PJ{n$3g)P;msj00yI=lbW(@JTp999| z!Qr(1zw73DofvTtxKi315v(vl9U$UPeSLR7@-p_Vo0FQDb3IX<4jzA;Dj6OG^N!Ew zhFwfbIuFZ68z9(?ovphLe+zmPS>UwBBmdRI0nd+9Eg8VhO4zx4%caIKH?a9Q;ob?c zny{B?YfitrH@3@-0Y?Jz?>q$&@8e``5G-ambM4yRdu@^OZFcy2Gi}HF<4qFylY$rV zsA~NESrBIcmjixVJGOcqa1=2leGDU(4BVvdK(&WeF^Hl;&-^tmtRht0VqH|;wWf5V&T)*(3f zM5;YL`HfZdR!UAuaU<1$vPfG^rR`}Jdoc)qLGp)e<6z2~{`#yZKJ$nc1~XjD3XCRn zX7vMCWkq2wjY}{?7@BU)*xYr`ZWk)o)q~M(&jHKPmzB(jgqU~d>y_aLBQIx>r!;#= z3)j)jtuO`T{E9|jigqP)+&=sC>eT^C=j0J!8rgGlC=&+o=dxA8nBh9Z5HlWzik7jqFy3FQiWyY;9wm=nsI!tBpU zyJgFCC#`#X+)n)O(j(_wZ}Yki+z4>Hz%w#A>ib;@g9*>Ef2nuIefC4Q@ZW((WbHJ30;wX;r!J{Q9%^O%}jlvu7}r|EX2a@q@VN z_S7AbwKKhZA_w>kD(_Pdr~&sKN2gnde*cs;u$K5FCaH(8NX^@$u0_C!?10J0$AS+6 zFKNvgj*fK$SNURWYb~P%D00~w*ce~xw&16POl2RrG#ZaX)>;6K#fZ=r(GV;JmRLlq zibG~S`a?Tp6sxT_T_avIT~!@!V26KyclY^~#;=LG=Jm8gy@^K4BF?0&v8#r$=q_3ph+#p$Y;et!Gl^_4?EUAg(^ zTGx7@*xa=8pvQNpn?#yi*x$W|5T2GL~jD+{;m8qxP z7;}b0SVUL06#J9jIqOCx47fog+qL}YqJS&3 z6Q2gUMuN|{PI`2sp@Ty&mMIL7j9#XwRE75V3cymoN&Vt8%`7-C=j;1NOKJZ44ERRd z(dZ%$l-1GHR0pG6a(@iz#*bAdo#Vc?LEdv=7`gJ%u#k~QKDKRH6oN|fbXcc8Cr{R- z$G2Tu(QbO2y8UCgq{?C+Y&h+eTgsi1bq}D&ls%Cs8!;U$i-{eURwm?YesyOT7Y*34 z3W|YbXZ=N=tkmZex52w6E1ol3Jcw> zYQ)WagSy9HcU*fR{zTq$?_t^?nO}ggg`&)sTPT8rXSep&l5jt;@uef^BzP`jVO24* zXozwz^wP9-7v}qtyYW(=rQD=xq&mT35bZl1Brp8X}w5-M)loHJKl*Vgr&g#`wN$U#{z0GhS4QR$DVYsMZ<= zZg9#+e3!{tNkXAvbhsQGuQ=wNv|=E75|XueUMWmelruL^$C3zqc^o{5~&rbI!}04aHFxl3A_Dy>vZ@3(E|8|nDLf`^dRZOr9ecJ zos8`Co56U9FgoetL--!3;52uYwUvx3fhE^min}LJSdTRW&2;BrW$*Q(*kSDnrFo|Vrc zV7Jg@nkM52HFi1FL!}IwE98Du)v90g*tsn~yBD-?5}8S^mf_35fg3Vj_W@l77Z##I zO}q66?#tiOs8sWb=>xN$!J?U{mMr%-zXz$2mg8wg>393MT^!zKF2yDv8U1;N@?J5sr)%#DcbR@p{O(8AFG2Q?xY= z*btVckm2y?WH+zBu+T93F>JGLMh*I}T-0r0Y0roPj|s(a1MT=Th{LLy|4hYD$Uts^({`udk_IF(Iy;E6u~p0Rjtv;O z5c~{!RK;)isncl6;86-0P(^on8pC(Mnz$&BR)ceu%!{F;Eh;?8^Z=*RpW>`voPRMO zG|RvZ!S%q3lF*!#wLqNo!V0h?=aB0mzNvv3(6D zK?RUw3Q<+kuA2g$hztY${jg}KjTn83un0i;@4~H)vA=r)W0JtD-e14o} zhE-dIx7EBK={fNo4~SCH8!DUz8%^Ggjs;-2Y<6Qidybm(y2I>h710>;&fa>KuGi4OBFCB-DhCW-IE_x+Z)`2=07 z@r%y#N%Tv5?{lMjw{FuHBf<4tqA+5Ka1?Qi5NND1K&iW!#ST8f+H%dEQX^=g5dB%^ zZ)vk(nk;N>%TeNWF~9D>{4V~XcPhLJ@8y&3{NK>w!?jUG6I2j$3{8+G7qAzRW?xo> zW@cuaj^x{k8Al+9!wr>)mQhluSE*iIrZYJ+eMq!Cy``o<1PgP-;YYi^IxpV3^-1Nd&NdAj29Hb5Ih?O4f3^-)EDU^R`1WyPH!rV8^OWeK_kCUveHm}%c_AyqnwGdN+(WO30e-&C~dUUTx6_e z+5oqbnxtU)hBj`>#Sn4c!GEF(@+hkt1p47&rx(^0EilQDB+aFHtoeM0K2?RU=^B$h3A{A zdP3P;2*mZSgq2B1($Yu1tH~|YUlGm>T%v0a=i44@l(qF;}KUG71r2-z?Pj|0gb$-cQRm=3_ZeE*s!F&t6>gc}L4n$O8AWnBgV8OjA% zbtjr1sa5g36lxb6O+4pLCAL-+J&vwcb8m7{ru~TiHL~WXi5#MShenoT5uqfnprvxp z!SduvuZatd_F;KZM!KW27MUU}6jQ@Cg9xXe=b`zYPY5>AnmRu2$g6+MA-*AlY4_uc zb~b)dH*$n*<)3JrgIKnW)krZrc1ZnVM6t+|a#>LAhHB%-iz&Au8@*-j^3=Mh<0goI zlS&Fsu`I71G7MEyxiuinGWzC27dEKGB?8wWAfUj;B4X2pQc@o6+?uhLOxyi$IZf~$ zo?tO`mQ}g+12=SHrote<2Mr`5rS(tQ=BbCLZ5ZE=N4c^L)>s70rQtCe;n8qOGJI?A z`qT*1cvQM7+#E(;oeiG}U$g}1rZ$Pb1GV!|%~84Qpaj(U{s3FR)Tpt5G&?(BVnRJW zKn&*%(p@uLLR8{E{=5DIZV>i#bKv*X`g(gV7Y9s(ZyZY0JO9JT2jsL}cB|!G5VT5r zX8{e&=Pzzha3ob;#G?wkt_G9b^!s=1|Ni^y&p)G4N0bfHrJ`X&C>0$@F`*+zqtJn$ zrYcCGN=ACdagjwkYik6-y`r0zwkfwU`e08L1-TUfVTeAm$gGb~tHZ7MBjslsRztf8 z{Zgx=G!EY!3Fpsgm5y*&c*m}oqJtCJQw$OJ(n2vTK!7X_|O&Edr@>TIE( z(0MCOp2$?da;b(9>vOR$X$^$DD&*7z8pu%bMRJ(4X=!1Iq6XKQ?N;c{e!mKT!+kNIysuS(iRiPGx{^G}qk zRKbPmI@C#l2_HUum@y5-2}fzXOH0Ex+f*)jt;ZLh8M<4&eJ4}}+3p+kEB5wg1e!JmJ&01vCXx(ok@v~d3iU+a}Nr`B|d5uL`82GlbBKUKux zqp}WmfCCF98NwUJB2o=D(Vi!UxrYlKYcPRw1^3F?K(zu$Y50Hd665dDJ6IDD%w3Al=|SoGJaw;zegd=xLMK>jZuml& z`}kEz_2}p7($CWjj-D{#B15SaSpf^Wr~Nnn9y9*Ue(^%?;AHS8G>F>Kg7Sk8DYGm} zZaM;+^oif=o{mp&_bJNNRclX?=hcb-5QRg6%d2-RCTJ)jB@H%4cwVde^Y60H&In|L z3l^Yu>!X}X($jpTX)*?&U86UYvmd;LMQxzG>DDpf>Y}x)(pGp^ex_z3p z0xeDw$-QTTxaKiSQ;R&RVWAQv~1be-Xpws!%+GvI<_js!jKaoE9c=icpJen3N-Q= zsS~uZG93etc=#u|cJQJ8>&>g9*%oCl;7Drn&N1FHp2Cep9?2lwckJ)eZdIiIW<);; zh2ZaK*Oo0Sn^-gf{2GK{wtw7rM1x;Hz3U$<8d7R=fdKn|;pZi;fJUY&EA%1vMEdD9 z?+bpNJUL@DuzU7FUBTpDjI);cmcKt_C>G3($DNRyuw0j=QK5G78Z@XJZipQxIRL;W zd;HP7WlQn>kf!ok5FDy=WMXKkfFf3C+S_ zN?LmlkB3N0YfAKlAW)c$?C+W8rY2+Wvc54sOFTT-t`1sgka}LMQdIfM3?}N1a*RFz zkhht6xY%MlcwVmuESJ=d4>ICK-m>u{nL6(3Zdv`+jrHv03x(TKs^!x#gU&orbuq8J zd(81H94$Gg`1{_(bKEmy%Ap6B;`hyC4q ze>W;UKpF!W@}VtZe}=ZU=$aG#NW6n#vt*0u?q!q(W$$qZ@U1$ItOXB;TA*{wF(I?J zEu`nOxF9})147H9zH8aCWywe9vc(pc3&Ogie~L%=gKZ^oqrgDpKV2FTaqInGIY|_K zklp4~KbZ?QlLd;&x#PW;LL9?eQ>!z!*=asvaqjHpWo#UQ`$2Iq3AU@%wb>Ug4J7df z>XxTFYKc;)M3ADE@CdUtv+Hc}z=WxT5%2<_3k<$e!d8qNA<>Pp#> z3daO>n55rFzeN?%*4j7OYG1b&cR|UEq{;+rnd&qqh}>X%PauKNS5*RT8_D1;xGX^Jy7HNGu7pDkY18faL=uIdM4uR?up(ikJamH9t{rW)FZ#s)alc; z)?3e_G`vu3VI>{I2b70^onYqV&MQYq?6kk(@N|2DrXGw&#NRpZu~ zPDQ8T;94K#4@$G^E82g_yO@g4@3))-xUI(QTx$(9-2mW_Ls*9n)sIJ*%~cDly@4v@ z1W@XPg1~o0MF}-|bh%&tV6=V8m!x%6%08W@-MYv3k8}RQBqu!5pAW+V!L8b17|`4( zdMqKcXRk_0aaG0*3v&S#IV zlF}@Fm{v*)y1$57I&mrYUqD+BnGr zv+qDf*|mx*2!GYv(%S2#p%t)*)q(dTYO3GI95S7)C=Ax_C06_cvni9qmyK7kc-EvR zSuH*Dh^5rD;g9di5tEC4E3VPTXE%M#iNyzRZX86KhQ0~W&kmr@$L-m7KW$u|oAhiM z_{sB%9!}$6h|1NNk*?^tSgV`OAIhdFZU+=Au4!{Dp+y^9?!4@8xnS3gvzTFB#5r$` zVLDbTlE8Vstct(3;R-@iaDY(L8CbL->2hWfq_2eH+qa(t1ZB;1rAK-F&*!@lX}Bfb#9#|=qdV^efQb!qE?etxmq zOD_-bSccWA@c*^J)WUreuGCpX}?7k@cPN!OtXgdE|keV?X%~+H^)3s}x zd!K6KgnaX$>rqrKYPwh-5GO?tM|e4&-up1 z*RMZ3Sp`N+TM~q>VRq<3kcC<4MaPZ}FuA}(*f;j-kqCLvKk72iYf)b=e{+m_pPqbX z_wwuccYmxO$(N6Dy3-{n!`0N3+Q;F}#s}l~KD_L`XeHC6|CDiG7cI&(^*3T#Bb2^f zi!ko63>iQZre;g*B8DO%!2I#!0{lJ$C&vzH>YcZS<>_yG!I$?VmfbG_{9K7L88br@Xzzl9H|PnmFS9 z19RGFh(*$)G^VT@OWuoQ5gF>FSm)BXceb8$+TG*rw@t-qtsg&s%h@?8@FFh7rLu%p zg*R!^cV9<*NO^0DB>4t&nZ<a1n$|MJNHP+!HJjp-aZ(1Y2NM`AhQ9e zlWuNYIQ)NK!%yeW$1V`Fkd8uckQCAM-~TxACvrFODcMb9?kvd-Tf+$hm};R)R4Y~8{16WN6V1y{+s&AZA3~gYF4&TQP+4Cp&OR; z4j^qgpALtZ0Vr41SAvIv{7-@|Ftch0r9X#^QF$~ZObp?)_?#$njF{lj=jp_8$Zte@ zM%2c@p%iR%iA#fu&h{xI+_dD8=+7CrMuryLLX%u_qkI7k#s%nV+Hf6;tK(@iYWeoM!YX=_@o`G`~ z>|83~ZY+@(5(q!Gy#0{0s_=G$Or}=t-mwfA1%*b=ZGw%dZtgp^r}^t>#Ht{J1C5I? z$P-kkYml_``rI#75o#ErpcEWhxW6DVc1<9(NBa5uXh0@`Kz5u)Jv+>($=A`uF5y0_ zbYx0M7oJv-814$bt(8CkVPS|zFf7UraJ0O_nrclqL>xfbOQ~fz0%tT(H=2K4HLT=5 zY;%gn$pb0-sJ*FW52o-;C<(|bOv`RjY%ux+EOGLDJ=7Fu`Ln^QTzEwz66DW%2*G&11F{|SfjL*S&gQ`P~DCu3vpR# z)Zw3@e;7!RktZeBt|Vze(Ey|-1?l0g6u&}N;i$gmY3(>+@x##%u%s2ukx_egf^Yt0 zBC}i-+W=cakC0;^O_?g;OenGlP@8(9SP7k+`EopM#aCKpfv-6ZoCO#|GihQ|$QE{> zgaF^G2bV&DWFqbs{oS%r9UMJd<-Iy|*svS|a{9cR!^N%PIH==*P&@k>-9(ct<@Ssu z8nQ_gvhvLaU}Jf?n>D4??t=$g$Sp>{jyV8boiJ%YKQLC%q1^@caUc8+I>$*9nj^^q z-%OVOAU1Hc9Y~eIzOLrvSq9!5I+P0M30q{fvrkRQalZS@R94oGwQ)XPit9@;^}Xb) z;A`43ivC3=96Z*+zA3GCu`&QYAYx_Cc6>a0$dh z&}YKFfVG`wGMG^u@zq*M@@OBrP<$5bch7P;WJiF%EsaPZGetSt3l5=wr&JKM#JElm z=5N0>CIa*YF#7kw0k_hi5-28Pj_b>hLM&nXogIXQoU1+H+ZAoZ=rGwp{k;Y<@z+p} zUM@twY#1*9IOZhyL~J>HxD|aOxnO`^WA$q4)H+z#&>us?9+uAen^=AzC4~l76cn7iW?MKeIx-T}<_96X!tJHKSh8)UhZC)YE9k4+Hx z>Oo$jbqhv=CfOa3Bz*+yEGkCxN$FZj1=XHD4RTtaUM&X3Us`!|E!< z>$898#~FDNQFE_mGW-eyhMRS{0Yz(iNPrz7ZZK+ofqIxO(0+pK)}i|uz#dCee-?Zp z3+3G*JhAjerf(=}$uyRJ@f(LWtxHa`6H#Su>C)t{wPg(GB_S%R_T`$&->DH145Ekp zq-*jJlx=@(q4o~$M?#bA!vc0Evn~6#<5xo$xh$1c<{XLt9JE1G^*u%uoBb0+-XG>=Fd)re?ya>|cR5kt0)$oZH-&$v#n z-ivrNK%=1T+ZX1~^I-J1Sj_307v|h*5|Nl&a zIFGUv^Kna|)MA#eZ`n3Fqcm1axIUEiQ0%QXEQ{0xwkV=zvEVhx;9xi36{PDFY+F{m zLnEzM(B~h6=QD@#8&}~Nl`pl%?Y3K5=%->m>iE*j*gs!+;>2Lt)nd4KWHQ+Sp3^ZE zN#uO8{>r&icWj)-L}sjv^|mG$C>68+Sviekr8s1*Uw+C{HSx3Ly_$@M$-R>OzvW}+6z5rV|b zSTk<4djgnv$61p9*#~&Sd(d_+=`VPEyD~j7@E6;M&k^)&4sXP%R+gO$?ey~D#VyI^ zf|Te>a%|)NAbGcvZY35Jq>Yu27WwFEkoJsC6r^Dn)m#>53ulPP;tO)i{^S^0%(}YP zm151;m>zdFa!!C96!9z|eu3_MBuCPuSZq8o|9#U)3(Nk>oAR1hMl(8-z+ln+V|HRL z2^)kp?@Z}xdsTBgV~}*K1#m_-k+SkXA8$Gaze%kc%hQcK{kAU5h;Bwba;pX4bVoPcin&#QIH9AdI#Afo28L6RLk1S%QH}m^**|-WNaRYW&oiNT$ew zPbq7T(rC-Ek@8R|Vg7{+@wOTM#y0&_SNS!B*3d+7De`3&dqu&oo(#~ySmwp$9xk(? zSiiU{+*siVf@v*IS?H) zTReXli%No-?d7|1sVi5kKnl8ozPrO(%Ha^A07{M9#cfGP$&ZYCm7k+Uz-kNlcRA%B zsJ{&1Pf);Up*H-UK<5TBXXEH&EJ08vM)0sCM=&nuZpww9{6%Icp5)E=!jlVg~H#?2uu%D5FouILeB?$^C$Uvf*BEt)q1ouasHcWe? zOe+X^4j-2$u9v3&jJU{tPo6wEiVhaS&XBI_um9bC6R)dX91Qw=IUZf%B*^O$>XE8k zbJ+#kEuKdTk|j7X_stD3(y_pyG?%ynpIJ$Xtl6#FxVtxI2yj9!;$#QSSuv9VTo0(4 zF7mYacGP%e9`!)Npb^o`+lWC|@^Aw(-e&j9sZ-!+b$RyXDM1zJFDi z4~I;3E7l8=Eg)oRDL$d^^mVYpCyPcv%R=7SgQ=FpAepBUcnazm(X(vx2kx_|7MQWu zrPMWQ#Pp%E{A|1Z5CMjUqGm(tQ^vjC^;FSY;IkS{dt* zbBe>u%=9ISIm&IfUt3alr?<6=L#H)5!hh9bYdErh|Neq>k74xFtdNV`v*#_Su_b7S zV9n4oaHcZeHqKN&EB6|zJ7o?l;}sC@C0HoE7^-W@y??!`#-N%faLvj)dp1&Ay|~&} zK5{)(3UP4~<+_MMK&h2XC6o+NgNwJPIA0 z4b8m^y82+a87oDGhU>gi`rOjNK<~cgW0NJg#Nf3qwJI-%AKv@rqR|93(b+Ul`xkJV zA}j|B)LRx9)X0oqL`Fm?^5DQ~xhczO;L}gLF?x=MjT`6u&U^shu-jYL{gVMS*+4^^ z)!+|Y6$jf@=?s(%M}5?qUYu7u6E!#+P#WXOkwc&tC*ad_r$<5v0UpfR8NyTH=(+lw zhSHP{a__+UNO=)K%;$W*KYbc?0eK#Kv0&siI4L@rB`;t4v~!94L=*hhx=jz^YK zS^lP445t8q_MP55ICrs`@`(CDyDgb^$idv|y7i~epNH=lf3O)NmK^L`AvJ*8J}@51 zyzX>(E1`LiptR)})f?3K0os;B??@rl-ia<{Yv(!QZo>Iu0%NcCHurWjJ$l^Ih7gxB zgH{m74P!I=#7}mOKNv-fC4ZLSZYJjmVvuxL01Q&J0BA6TlOanURb6`9Qq3G8m14xg z$z;3EEN%IOH0-#0I!NZjYFZRMQmR(D(XDIb($vfN_=&nL*y}iHXA%7k4{sa31w+^v z$h6vfL93+qg!2Gn|JIeCA9w$43`QG#DMc1S>6sZvlBNG}p95o4D; zXmnCW7Xr&J1249BI|NsTYG`;myl$Cym?YfirQ{A`>xHoTszdYQ**6ynZ2GJ#9=I3n z{H<^Dcq$3HOS|h zq)g@dV!SS?7K5s^C+|`n%9E4ITwab$XOr^q1c|k_G|&{6ofaDIICSCQ21~OCwz9@k*g~^FwR#!ldQo2VBlWKW-||R8wFem z;WU?s9Y@67S704Cdr6~)4Uf@Ih)`O6ujcPA0CX=QH{_(ve^N<~*lcr%?z$*yTDH-*(8Oo#4aXPShkjo9NvzId`3jIe&! z^Y-QQ_^Oh^y5!E;3W8y1^9~v^Q*&FX`xO7u)90pEu$90!ApdeNMyeXFa1{<dHDR`?DgM%Te$B~ zZr=IxSx{^|J}gwuaW;BCd#|Oi3r(a~R%BrgHoar2c8Tdz@PuQ{(DbFdR7wjTh6P?^k zahBR3_k?fjrGEd<#H2pF5L5Njf|+!lxCTsyZmu9t*GBWRhbJa*{~cUTIN|^yil17# z3-QRaqW7f|8a6$gY@zWvg^O^?4%-*o_XYJKQ{%``K?8O?H#jO1L;MGd4R8}t5 zHJvMGOVh`=AS2hRgv6agM_?B-U@LQ7f9K zZGp%mA7)9Pf`YD$oIM*14<^e2)C<^`5D6XrIx*iD6PavA&wD72wk}TT%|7sM#T(RJ zTl|Skc5)r&xzR%L^wRk)5MV{qN-$;obDjS#eOYhY+l3F*j#m0#L(sQ7^UwH#xoajM zYLpcEhaci8-qtLct5qFemQlIwc-PL)k_p$ z&v1k&l-@RO7NG|h>Sb^+kZru5&;9XgW4k~8x50jWz`=QGMQH7K3ifT5L-2iT`h|{a zPim@fdJ6$5s?u9EF5@bkPns%isHREr^UNJi+;@=ubInNgqy#7?4)v=*XjfkyKt z$p#|uqHwo3&&b~vpa@-w!P7Nrq1WF2q^Ty*i2LCB3}P@OLYdYrP*PvJdpCi#c%o-9 ztQ76aT=u6coTT7oipFKTm<33SzKAi}i^VB>!YYGNA%FmnD-ZK`g@T8C{HU5PjZDAp zS_hkgXcoQMK9!^Gnx27rq;ZF8ZCVOyFZGmS#z4_N=hTZjq5zV-`b4mD>~(_kl6|Bj zp>&~x=OTA{aZFEWp(jQk6bM?SBbp3YjB0!4`dA@>ST0|!eLz%9xlBEAQWrH$+j-Q; zO;}XvBZD&Vi7&Aw+}7RpvdzHv?BNz^=3l%> zUT^sVU)LCbBA9#Bm`2^UR;x8VX(izUU~^yAqhTD8h*d(^>=Rcvt-IN0?rNJ~;TBl+ zCeE|~eME}H@6CKj7*^4Eod{~Ram1OdYzEXY;o|uPSC|5eNGwzrQNRH-eMEed3F5aD z*Bn57UUq1tjp}geGj3toZQI#$>&heoT^ameGZ_d5l8C0T>`76QPx8uqF^yF~V|lB9 zHJ!kw(Dmx`2)kIhax##Suo5SluEbTVd6-*e8(CG)wO`yEE0YY{KkW?EQU96$Zc8`% pA0y1uOy=w+hNC;qfXVA{=+MF{5XEGQJ&doX+yBG|X0S1G8Av+uX z=GTk^gZLMl`BrTW#yI_7O!mEt42CFUvxe%PGdJ6QIPKZfoG;h4$x~eCvbZVBo^wn8 zsdax=${9vWtpO{1aE)cGtUlM&RT>zuVL6=I~DZ zBgeFIKx6VBUC#^EOjAD~efaRH*elB z7(p7$t5&T#cKo>N?%i_)1qF|Nd3ZRxQPS?e53h{P$XL5*(IU}Jn}qJ)zpt}nhqjg$ z+pb-^&PPOey?eLqY^=1jbm~Qp<;$0sRaE%iy}P8hx7XCvl)=Kn^1HRQpsb9?>e~~) z*jTZU(9qb#L_^8>2_2i)2P;indHJ`^Tehg3KE2l5-2D9c^PU3(X9n$$AHP51cK!Nw znYC+^^pg5|dmEdEJGrf_+7BGP|KNcdZs(M}eUk#$0})nMRyjwh+xPBCEMCl7R8-W{ zS6NwUcJd^Lg@wh{t5;uERPgQFw=eC<6aSo?F@?dLgzeuChGpfJM&2xg&6{UjxNyO; z?P|i8++FI(A^U%0KSJ1=@FkYgpETW%clvkOkZ#UR; z*yx2LCoXvBzI|6jDm%*Krza&Rmp?kX@rW4xRAXCPTTdS! zmbUix1#Q=6>2l1Pd@*u1*REY#Z})TB_M7Xywnj?D-o8EU%9Shh)A8{VY}~>eST*Su z>t_D>^C$C6xA=!!3ITO>rdTK{SVt0CAukJq=G3>fap>ym;>Y$*EzpV)ysU^P4F78{3aehE=sLiYmzTHRZD_5xkB?Y{PTlX{fv+!0 zT71v6vsoJ?n$7p$RdV0CbEm7jJ1@s=xT{3OL*?K>p@!m6pBpz8_;W5`)6~>Vmsock zKeOJcW1*|7tL@Li8JDhHF|STDvvqPR!6nAtE_{)hyLg`K#GkXfELtHHBVi^G5CD*bmCg3DK|NI(1ci0j|?^2e%Dg!ZKxhc4TFx9jVW*4?bE zg)aZv^1ePkp=WFy=Fs}t?8D6s=XDmDYoGZ2-vxBPIQ?g~($H^-MT-}k^|e$QJU_iG zyjuPgc9_8n$5rdBzWUZ=yIA0DVQbA(*r)EeTeWT4WC60-vi!0+en&vbbv+iiU1!ZE z*RjFomHoOZt)G*-NBe8B%4b?yS_-VU6?Gr_BiSX;_qLmTYSnGQtzTVdC5UC({b`4? z+1SXSxpv&fU3>TX;Zo}pQ*-iNIzqkMT(ly6I)X-vbx%!y1H7$#6(2i`n%~f8!fCC z{}WXyv1w^Mj*gBxn>X_+?DEN%n5?T6$N1*XjolHgR905@^2?*6t$pm)W@cg)m6fgS ze+&2R*)vT}PA=UdYp0qTvsQ=z6KbDP)*0R{Teg^MTe6>-HubIHezW-F5)#iB??va<5&-(^froi)jkMh-=9-_8mP3row$xFmhzn8liP>$G<6 zK`>CKG}Gw~t{o>+a0L3Oo>ZmqBP8X0ljvv==k!|;Kp)|_r` zZm3@mqApa1qE5smC2{P!zb7Y2EG*f+`GdhzYazu=o9zDn(#6NJ|IY(bROKm)*XB0Z zzn@lo-`HThcDR*awUhXtSpx2ooc-VrU;!y2I=Ok-rnBluU=j1xUhVx$LRU+^YAcc&6?HQ_GNd) zLcEZd33~BmcXb!6->{*+yP<^P`Te^QZ6`dEuD^d-7#dnyKWoRwV0~&dU4oW4T?scgvn?)SDJz}XAgssV)TqzU0vOEe6;_uU=_+veMd)_bj|>CFu!z)UE`Rh zh0FewmhXMXD-!g|K7LeFQBleEa8xgt+W(w2$%apjH@rT0@a>y7`Ba!*OGcYkKG>US zThENb8FJym?Av$lh%H&dhSKe`Z3zoQKtMor_3GK(-QDzju1K4N6$Efo9~kfV7?-T= z$Tf(flqZw+-B!zU;6@Q%9v+>8F%nwqP% zWy?(W;dXh00|(4U2D;^HY)nl($3}-)7@t!P23!Alj%v>2Go4%O%$dv)x7k6ri?7Z2 z@xlquo6j>hZ2Pw_UsRV|H2d}L8Wl^FRyKT*>qvJAt|k9p`?sc6w&~L?+N#r2H{He4 zqk4jpbl;VE)4_uWIfNAr#-jK`+oMkf<-K~vj@KXO>ZqRo-|H}bdu3JAz1Uz)b@lk- zPHSsxhNyI_^mG0fadAKGQ|~7x#;2w292*w#81b6BVqZ*VrogwSHYK48B}S;lqoksh(-KT4|EAaM`kD18t8=>sne4B$hsX@`R1CaKowF z#XS!mEFbiB=DhXvsr-Q_Cxgo4wS$E;Pybif>gF$4P*7CFdg5~uZ_@!+baFmEK9%K{ znHkemU((i2%^8|GZ{9qHsPf+NFV`9qOV=kDrw+MQR#k6ZG@J1fPl#7YDD>b9N7`su z6M^T>sX04uyuEALq1F3CtrXvW`7)oDU}@B**!cL}iFRMUd@%zqsD5;m8@1FQ>kMdv zB{nwp)w_3vvFZU>1wHxc*~|6aUcG%=fOb*W(ZPkXUw&#W-#J|7ehEkRNtmwxrz%wh zMOAO-PKLI2iSuY1mPH*32?2+(k-s~9eSKeILkJ5CGdvUZQ}eMGxrG%~_U)VZ?)`ha z@iDiP)oDx{Hf&hBe0jbn6N~N0fZfS&PY67sQB!+dy?QmeS_t}89-a}3ML=$@a+Km( z?>BF@oH=`znizigcUde;Z(rYuLl<=xWqOP&6^9AYUaWLJNj34n0YRXMF6>@4U0qIp ze}96>p`n})A3aKU9~~03AQ14x`o~cCvzCIJ8|=FpU(Z>%@iaSNDB1z%wsRT@@1KcG zHhuB0cxu1i-w1egv@}02Pql45r$0a?7FFZZ=O?%Zoa#5oN9R^CO<;aK7CD!HC-DqS ze-;K2#vAKP^#~H$e7duBM6sEBd{7p^!7uv-QgG(fplDS{mkyKQAZ69ozZeVxU6jFnKNfzzIij#spEUzovo2kE<27Kxy$~#r3MR3 z*8bPFmBv{DwQl{ls_g{%wm;OKxc<;{c-veH*L$MZ6uf>tLwTf2J^9Ejo0+Fip9Wm_ z4-8~KS(_vD{P}Zp?FaU|?(?nCPbuvE^C|u0m(?e~W^7j4EH>&_HB~6%7qK&cPBjVN zo4C&m9RllVNAl5#d&Oe1vb<}Kyi+-JXc3<3IrOYxq5ERbU;hU&mTq1&dt|tFytw1X z3!)3BJHF4qA#Y>7w%_KS{)!bV3V;Yrj~@@hrK0^k{65a|AKcsX@zbYtn_8u;@v&iW zro!nWu8g^J=W;Aq#}Vy5w5+YIjYn8m%5j_XRxvTL-=FSrkKt>~!SmQ>%~HohE()uR z`JYz2lD*wEgdQ4ngPrd`Is%L7dG+ik+6*KBw@wvGxWX^QeISaF9 zr=WOXNwU>?jBk=M$qB*sG%q?gR{({jx?J$$jj1ZK=sAAQD93d^6B83IOdFkY?b@|< zjg7wP7A5B39H|Z_{kgL^IsNY4liVJy6gq|IudX@Dg^kl{%D2Z5O}RS9O(82gJL1~4 zAY5|;N`1iN$B*$v5>szrcEGkJ>c@^P4HHog1Naxmn`UEU6IgSEqc~)~PlSYa9KdU5 z<0EW7zxHoW8|w0W&TqMMRq^cV8jo=|dQYnkWSo(VR!zMJevT^I_3xiQb~G+l23sZb z#ft(k?Y1+a^QU-EWi&QA`lHBt_mTA@BO}Dcv23Vde)#a=HyYTjnr~UC0@Jw`dPYX_ z;}OOrCx_y$^YJ5i)Y6;UqieQN~U8KB_t&kf*UmzJy#FlifeQp8IZ+g)HOE;yp5Dr-@ku8{@M=}V4;vu zdA5s_-YGfO)z>(%{fUTy(}9DsG0-cPF4=xF(5|5vja#Sjk}lWOw`IFv{j$%TnGcd} zhi1da&tFhn%qArzWou{Wm7bnn&3oe2t5=?QMjxU!1p~*5$;!0i?-F9DgN{O z$NATX2(596D1|hXgiGMF*R5Meg?EYW^@?L*)o%{1rha#{G)fb&9ArgLPmjsU$_kX? zmB=QSf4(UxDb;qG5f?6a<6Shoxx6CNb#OIt#<)1~1n~H}mtH+Dgn)N1DrmNF|996L z?(aFb=IDo)c*bL6W3Ng}1Aqj+fB!CX{NtkEpuj@i$(JJ|8vx-l-A6ZCf6w&7=BfvW zU@!pkPj}V`{dn%64(e)#Isryr@ak1UIlm#0#qHaRXfI;_$_YPv_H5^#J-&DDEC$Fx zdto!h)%>o>R=9NOQejw)(SN0&9sS+3vnIRxg_HEph6czRVZfMXUo(!UVPz>8-+KG@ ztvaL|uo7MfCHKbYI@S0*nH@XEuB-drdA@SxvZ;#XYz#2r z*#6b8)_s^0*y1Imq`F_f{P6-S*FV^%!C9>P!Chsd`JI9YR3x1{!Ym>pa_rbK(~j@Y zu5NN!2P9GyrlpbkauP>ZylZM~dklUho5fUX`_A3tPCs+c?`fNGLS0hB3L+_11{90~|2dLHbHdlj&`#oP}0b zd}-Nk3si$b@~bpD99<(0+LgJsM4VH|B>qmA;oQ?WW1aQ)K!87W=y?EP23coh zp@&F1t`&bEG1WSBbqvkwPOA++banONnMp}WJOHIc?f^Y63{%w}Ety5WPl*!YX-7ie{3^?H36cuP3IQ3k;g3g`uhBWBUEyA^X z_ihbsZPJHiKx-8QdF4!}9xEroPE@qA7fv>fjg6v<7ERL*7xn`KqHp9iom@q;ukBf0 zv_pB+7Y$PkKSG48ueD0nb-Xao18&^Ty>4W)H>XR1(pBt&Q>azk~^YEHA3(GHO*P0_w$)^ z6QY#frtW|Lic!M#fCPc3W}w^nU6?%{c{8wvbF9jDVx5L*;(lLWSeyyWjJM%S?8NG8 z2Cu@rY`?55MZS6SNcTZ)oYdoUM*7hRpx(tkcrbHtaIohnYBY+=;3HH-Gqc!{XHv&4 zE!BVo#**&bVGYs{_khaG#yEE3#M{Wk#6%KXPyl!8>qkl_jvWNE-M(gb`xG*+jDY-; zWSlLSJJK_2sJ}D3wJJ3pB7k{G+;}R!4`k@o>({Cvexc1+k zgv+Pf%*qiTs-z-Ll%(7Gzl?2&f)C+Frix>4wa{bJr}syqtQhz;oNwnu+o zc_4!wm3UyNH8tHdk2xyLB%F#Q2z6uQA&4dQz+G@2s3SyNxkB9xGP3&e%byK)=<2qM zY<++)TPr8mbmz(QcPEY?e?7}(_n!UxgYxs$2CvO3jmqAco#cGOU66d$GvpX}? zdw=AT9Ue46#`Dim{cx=)=z{Sl@Ki*x6jI3HZ2GC7} z6}`k3Z1~dU%S?=or+@E^?}a=ngq@&!)?8)ktL68i@n2q{|38)TB_PMuPYNo-q} zUlxachWeT5HoPt_E{-f7tR;pgp69!F?@Z0inC$KCuim%;WX&P8@ifnd4RZ6)aq$`p zVWH4dD=aD!!)E|asYBjkyeur7Mph3g2IbG}k76eW-W*GwLQB~}a6epo%e7xY^n*Ci zRUaUtCLR$el&HE{S636{AU{8!2hIz8Cfs8@WF?5Z8h}^jiTcum>RY#NZF^PWd-%u^ zagZ|_Lw>lq0$t=wGn?+8-_-Lnxt-bw;&)V%4 z=H@&+Jf5hN^(~c&_(t!X93_8_`Qpm6Ev>BHpJ=?Vw@gZ^7&2+2!UL$S-fe9sVS<@K zuYkWaq5YDk6+b34S*6Pp!4b{7e-^E`tz$rM^MY2FzQ1ND1!Rdd16x}eq7-xHu;2x9 z%wIiCLOZN5kXOR=@Zn0nl*3Cd!2Zf~Xq^Z7num|i7l1?O&aU2$9}BSNi7*rM@CBv_<_(=}n!h!pvOm}S_#uP}9dP&V-RkrfY))2i zGERUoz^izaT|E7(8y%J#85zM<6?N2zW0MdQW6H_NA@z|s0PGl2Qix81ZnfG^pK5O9 zwYS#WF^jnM@&bM`!KDS$InbulNAwgzcs?XDyUaZyFUO)ecnm~QDw`{KYzZgwEp3UTRmBmH9vq` zL<>fbtjCz^N`o{;ad9!=mt_VjQ8$Ql!MAShg~eMJ9l zjzZv9Z+OS=Zf=+ZN|YSDf57IH^HxGRmY-o3%N~Bix9zG76M9~zee?E<(*3Vrzb0%- z?GZ2b<|dbU<>lqD4URsObS}xr$msfVG@6*zde;FNC=47Ze@RBqWHBFD}s~$v@4uUX5VayQ{M1CE^jA@9Z+lcAg7mQg!Ff^RCaLqeW0dJyC?uUG0!I zHa5o62MN66x?lZ`z9F&zq|$bE)vJfhUqjf`Ak$Xt_O3sMHa8|;`Sr`0nd>LB0GpJyYeyZTu_Oi;vBlO;m=r@rl zYl1^VL&qu~Tn_v*w%Vz~2&KJp=}XRKwKqPNm*;^X+jiBd5_bUAU%Fz2OQO}o30Y0= z5&4<4XR*aI?HbsCAq&IyG{1TKR@N+k8u7-pYx!V1^C--g69riZrth|Y3)_!ZSeOge zEAOt#+X)GQXv9?ppU?MXCj(JP09r!dy()KN9z@NWGlr8OwW9Ix(W4}#ka$LB3|3U- z`X5i18D=}nS=Z)-5=95JXj@;wczp89t~U1fHK14IEkhuwk2G;V+c1U2^e)a55MYOR zM~?y?h{2;HoWunklbj>2UJVp+A7H{>A;w-5wtGcHLyBYN6xI@xbcn2oM}wC zV?!&j(>%Rcrkgjuihu&98rtVEKI%mE9_+>snk|G}%f2DVJ88$t#mOEK*yOwx{M2uP z#BSThu`k7F2Kt@i*`8_RgQXs2_jgN@wFkJ1r(E#x@Y^zUH1Z!|;q|m*)BYSE>l`mj zHk1cNHO=>(aqQDwPLc~CSLgie-+iNfV!=Dk?nQMFP<2-dLCS^{XII5G1@s zfE&ILEf2V*Tt(OLE>#-lNZgm~{C5T`>%?wYl8}{UWbp7%kZ6RCFW%!UpdARaPEZ50 zsYXH+J|}eNGoXbZ__-?2*wCYe3XVx5kD-H^OxsngCV9C|%*WWzy7;K9428@b< zX0p=o$+q<#V_CLs)v~Jk`uaN|IUs~!+&X;rM|+m#N@%K(vUwToxugGXh_ZV_cwIri z!w?-98hWGrcW>=Cthi+i9<%~6lY4kF0%(&bLhpaYg7L-w&%_?bhp0gYkAchyuQ6+F z?X@*W3DKznAYo00rlBaBz4T;KgSnHeWOx!@h#EjLtBp;k{Qgn4$u=yv0qbU4{W1DcwC^g=*3-$sI+&cv6Z%Bp>PV%4;GH_tRP1T&Z! z^6kJFh-IQ&qkg9Mc zm)}*D#}}S;#nQ6Wp&Go!C?&V$P&{Y+Z7z+>l@t|KAr@@nvJDvrZxjX8p*+F22aSvx zS;sX8@$(@6k_;YU#WP)BqpNtnR9CY{yY{@kk>u=i?>F&xy^E*nUNRx4qvAfC`b#FF z<}FD0x;I~Xz@)q&0sp+XL&*y+2A(hk=xGcR1QFAyhg(lBHA;aP(P}VlbwB`I0U+N4 z*}>~6DN+FFY)~`xbKLt{_Cg9(b~@^Zz0S<|5UtEzml{;-ncHDytP3wRDi^USL5Apx z6 zibJY|KSg_t1tB~HkvzV*C%1G?SHJ5^liC+>AD*B7(?ieTF{=6E#fxn+q^8!#4E*V; zyp1qXCA24QSPMSTfU46qD(`INN4hFVs3CNrlB)m&Xc*Vt*tS_AKq34(N>u`uK{nOMmZ3G~Tgo+cXB0f(nC_#Kc)B{-{S;YaeNdpZ)Vt|9wab0Fs16{L>u% zp-11&-bf$$k(l$;5=)mfXmZ8DUJe~ToL5oN`&hY|Y}4zVg&vTiv8PmVeYMBjCSjjt z?}N7^*cCjpXM3X>se-7r8N}J!*{K4D1EY#NUOKRQ@7^N(NSepEJ5~;vJDD#1QV3c^ zT)O0o>uUb|`pp|}e}6VKQ*6`W@2ya=Q(d!%*!!R&n_Nwl>eL_?ar+aK>|0J7uIRhj zR01+^D<~+O{PBD)ObS~^$CSPQTFgzd?c<(pfVK~5wEpMM9$UK$^vAW(9>|m8P)41pqTkyjf@MJaAySyBQx7B#2-Bk8~ z3exK-%0BQjSlTk_B76gEw0Mv4F@`7bZsmH*F(80}fq|?Z2l&X)0~O_6TzBo7jrAgf z3bS#(Jy_xDHEU$g_B1*@nYxS8139i6C^-etlvi2#c;6s=VB;6Y>c(WmJ(MCAXmo0lPL=nM+tP5Q-@wJ#G=D!lt*8 zcE8KSez&xc*Ms0l0g4YU{1CN4NJgIF;oJ}ej0c~iF3yuO3Os+FCqzJ&nUQw*?Ywu_ z<+kRq+=su-u)Mj;BpXV}ww$D)zTDa?DacUa$!mcKGBHRPM7+xnI(kKmi*u!;@zIq) ziKU@;oC9_`SQ{FC^BAd#YHDi>!S;>^Cn_s1zh8L<{Y~a%wM^TWN7GT`ijwv};sHZO zyE=5_$WJ&c0?O_q_Ja@pzCE;B=gvod~YVLZp;k(;!y*V{L8zPh!7$ZT;k-_F@0eS0%2Oe84c1-eE1n~d?vzy=u z^eaTIa2wcxhzyv1yuDdx`}ShcAX`{;AZPW>(H>eTh1N_5T~3amMR;d8rjn@NeZ!C)A2WoZbN*~ zz))zW&z>`<9+EJ?VjMPhwsW8NlPBv&Mn~}Lq{vE2miz> zkExEho=mM^xWCh*_3e_HO2-z^S~AfEM?Ne{zXiV&5j7>C8YP4`Wk3LKFgO5-3^!MlF1t(9QgaNRx;j>kRE#7B#Pkm>nwBx(TjUHo) z=;^~o&urQnoFie8Fdsd7G^@YHh5RmfJGD=~v((8=Z^E2F{5X5jzJ* zQu0%u87R&~`Xt)>co_~M$JwQ`WY^a~OG5@=Fj~sOU zKBY5S+5#z)$A{kDfV7=};+ZrohOCbtceT~#iqNOy@yI}c-xjST1YWEKkE1Y5yW$vm zdeF~{@H}aY5IX}SD7wA*V$0CF%TshFjgoUyu_CP8ieuIem3!E|JyGr2P))%}r<~ur z+pc-zH5LF9w*_i&Zbz7rGPAwE^}c7For6k}=R0Fg9RLf}I(?3*#woC6>sCTBP|Yj` zdzuD1UUbIXF5D1XwCBKqbNDDU6H&k`~zpE>j9=iuuiushM0#1Uc! z?Z`a)cS*+M$FkUu&?C$t+B>*qjA>4CZ5>xgf~0Veh>sFODKi8^bMH$H-`jpm4WJ+E zANj{wP-CbFLIG;LKT>fU&5j+*k*s72cmbFTAXkKl2Rv`S#0ur$Np4#>7xF@Xt%nF= zFzX%L1h7gGB25)#XC}Ufn;?O}%*>2{iJu=U_LAw*qtnqK5qLXgu3>rU(CYbQgF@d! zG(;4!M=YbAdU|=_>k}Tcpxn$~(6F@K=1pRypm?-JN|9h4$~v^{L1;%6af&vBUN+Pi zUVspU4S&LPK!a34nhFob44yW=vHI)RIEeWUaxUx34PSrwPz+%=~UiZS76ROW)cqQA|;qsvESN_QPRCH%)q4L3m$6nz9Pqqw5t zLaclS1Ge_**3X>iQkRuiu3B|=m2zcpOYRN4@*Zt4OE^+M{RpPafb?Abcp~@-XPafsnl*T*`4ENizF_G2z`RBg*WA8? z6YGcxJ~%0|XCuOcgA1_YDdNR|VJ1hKvX#}r_%hfJK{v;4Sxh)tanJkP`u?Fu7NI>M z>%P))r6uL~Z5xU?Zz`Uh4gFLD!Vi2B8JikKFmh1EdEp|;T6nM>wYl8)_snEKEtw0b zV`^zR6NU_^^yh&e)zw$;jmn<_j)iAP4$KG{=z!~>R04RIOQof!GeB2kK%BrrsntOY zT|E8*DUek?IxU=23nBUEPje(crn|elQx`|jRmySE?ESb=JUY^FQ6r$e#v%DEpy0R? zWY6sI;lBJn@CxuF7Q#_j=sG$&D$wvLe^ywi0l59THZeBV3-&Yoak5u@A|iNk3yp8T zKDFUSHX5z`VUE9UDOd?f>oiPq^Cr}QJ*4BHp5p5?VTEAS0$@knqy({609g$z*G6tk zc2Kkc8kr_U0gZ)vK2r|0gCvpzbCzsVfx+PF=4NJNBaM66eCpI{{D~L$0&oQ-9o;$) zS|=8wZ+d#Sp@){8U3%7lGB5~vFx$6Zi7W;Qg}qc|ppB>k@CyK&D)drIMdjfHV=V1r z1*Q>QV`E`#)QF20eIQ=rmc178A3TtPG56(s2ROs%Fa3BrV0Oi_gJN@&G^mh?s4M{2?Sbmq{Y zre?#O(g-RgTL^WtJ?Y~G@;q9GKW7>SCE41mbm*xVc+6T=|q5>_Cr$*gzE zFWNNm>Em`KoBQVTfj(*j7h*nSPonI{S(A21`HN=2I7+}F(@QS(*~a8+WaVSz1Gpm` z-V;G4ER6#6Dg;kCTwI2=`khplUw*UIWBc~7tnd5yf3#dM#FgXP20H;DxZSIls2q`E;2D;oYL zZ|9L4rGyzD6biSdzTWqj5!_N$^%~i~{Bj({fJdBc9$Lfz@FKRp9035c^P-cooF;>`!0h-^c@W zUT#P_HeO~d7z^Tr2>0!8)9DRE#O9UF;eLQ?n7vF$l@{F9y@BWPZo|AlL5A>T5qWwF z0np56&&*Icfzw~klAIY|tj#kGt%%}S;EgB&ve;nAZ8d7SAb2{bWHMFQdj!QM?Nrm2 zB$HfWB(q9T?PDQ2Ij(fximRgZ7-iO=3Fl*vVe@z*;OoyNbZ#P15D{qXJ=q^ElL5y8 zK8pbl>YJMU&i?%sBotJ$6E%gIg{8is!3UZsREJp*wJ7Ky`C7vA(3F2(`38tZ1{%ce zyLW%$38X!KJXc|M*9QHlf1M&=3k;y2Na~_Nf66XE$`V0!-^5 z=@N*b$SL#3S{hKq!7y0UHp*#iO2+5(1~?%u|-QyG=_bt7P^^JhkrV@sa6-tw6mt zTr+0**CyA82ahQ5#b|eB%FCUo+78sTM}BIZG);*+SZQX^cwsH@E6mRJM6dx8LR~|{ z-|upL5V_%b`Bd`;C3JL80(s|j#Gpb%l!YnM0JI34A?dhi=mypdV$&3s&{R`ne(ujW}r}bphn@O4I^jt{4}8>4fG7;`KC`!&bUBiTYsvNoj!u31XM=s;i9NbE(A+; z7R{#D#q#pRL>5P<1JiIM1W~w;C=ZD#I`8)(>V@BDCtqoj8Pb3b^^_AQW`Q!(M-)s& zJAO;Ux5$&Pb@icaO=4=!PdzhUg2#y2VBSj=mLHfqbVFv)DFD6;3Pypyqirv20+NsW zl>*k@(a}Mi7RoraRt*2FDE;8+ft7;aGo@TE%;Ms35pJ4K!xu~BP41ZY1^`glgZ>2E z={97{yn)48Re8v~#mlV6FQNqa!wsdy+R`!;vkLSH4Fyx5uonsmMXg~sliq@<6dr|L z7bDT2@$k*Z$3_XhU`Yjl$y%U3PUh1B6Cx%tgQY+2LB_GoAOo|7*rbZ)Mgat|@h)s^ zY^F`0u8z1iSw6T*8JObRuV`y@P9i(KHGd(qTeMW%hhJL)EiV@8q2ui(_lBMi;nMSJ zYek@-L0VA6u9b!SfSP_zC?fFsq>mqW)4mt&5JHHf8Zk? zkETdi`N7^5$B?!G4@7AoFb7vE_RbwY^bFO>;2r+5Pho*VrSwGaj$5)4Dg(U&Oo`YI z^&W>+Lo^sc;v&rZU~~K6a!5&n%Z3HSj2tg+wT}uU_7Ua@G%PJ2j5NbIKm-WMRej@M zi5^$B+>!nfg)UCt9vjPqH+8n&{nMJ0P>d}{j1dMzCxoVqaNxF_i?NxR19!gBfDg<{ zLUq!kmCCKHt?D~=a3dLpd~5Q^QDg6qGCI(%3%OJ&$kk~KXhbU$DD5W3#(dZ~XDjTA zzl3xnR%Sj*V^yk20I(XRlF@JS5HfB%)63QL>zBBgSZuKb02b!+5WH2v2r%kfQ>Q+j zA_6g4y*UXyyaYIppLbrA_=F zJzDeJq17MNQ5AvGHl0u{h*M+%o0ynTi~+#}^nw8V*n|$J_`nYm5?&4sfFa#dgeKGt zXbs%O!ocEeTnr$x2kS!w!65PQnB&;87ounA9UKx-b`Jq_AqfENj={jSoNoU*7c((3 z^77izN^WKMc8EaxJg4ZbYIYqkw7+#~a60mRzg{ z7cZf$)Y-|+>Nj3e;})Rlkm12H{xRagY4%EQQ+__p#mo<@ce0#YEbxLSNK4mTN48wD zTthheD$iEF5Cava(8Zd((?US~wQkQ0Jbim}>(B9O6`rEPL zMX*chyKB5fh_R%b7tKVvxc{43RW=RTq7D=C@n04Iiy2Wc(sZF&#@xNjHgo1o%7mlE{Y)vP<9eoP%*_|e8Cjo7Nt0!*^2?t zHtNtjd+`8Wi&*x2i;1z3e;q%9$)E=H`KfSQ_}=s9f)qM|w2bExgSl#cSEk$cA2W+QDIv>tZhhqhOT785?SqriY4|eW*4B z0*;hMh2m`>jd#9N=Ebc4uH^F0rG?l`v`fVC- zMxLs#swP`FF+H6Z4}!)F2wh^wA&tO_n*>1hMVUlOkS>K8bvV zI=p)dLPB_OYhR-^LrDzpL&pYK*avqfhWbGM2wd$!t{^7>g9*kCGBq^h{4QEq1R&E# zMfCRxbw1P ziV0v%<0poj7Fnpp^6*O;c|y)dgbtQ@AQZ2LTTV53kV*%+!bi4RSV%ypOv5-B3HeC3 zQF6$@H%sCC2KT?)q{30sE!^XAnm6Ogv zDbzd=6ihgKgA@T}*kUXUG|K|_Kk8iL6}4?CpE;s%gyjHZXaoeG|8ZE;`4;BGNYn+z zhr;6nrysJjZ;h>k!a<+OTUJLK<)mO6qBl@yP>x>X8}DMD@k<*Qg3|E_3eH5qrK*SY z&7G)PV>*9?d|i|~$IhBil$ib-m9qdspjwnV3H-PVK^3*~dqa-#ICg|HL-fBFaUWOLWv$G zqRW;A;kKy|!<_Ve_G|;*;Q&|SLAUW6+7k=mEqQU2NyLaTz&i$4i=A{*_qw@l!Yu^N zn6u<1NIGh8^~1vxQ@BV2pk5@Dt~=H%hyCn>@`ma_BD7h7f49)Cr|7_{XU}fH!ut9{ za^prpAhm%~k1@3THtUd%K11jtmM2b#@y%p9oiyh58aRpqi?F09jDsmD*MN#8|1A<8 zZf7?^x3tpg2R(G*|zpT7`2{_F2WpOEsF%AKpxx-GorM3!ggcu4V@DA1EmX?+Q zuKRQUyNp0MAwQ9}c?s^%juDWYg0rhoDqu#<@>21{eb+-wAghi>WO1s%f(19+WpBQa z{)%Tt5T>(phlEs=&j;PwxR@AE64^0gMtq~TK10nzcVa`FDHbTe#`lIZPDhngXWB{B zie*29#JjKcv;6o{M|=BLr%fJix}+_-x^`h8g${9W4fwRASb%26I2WuV2Ng<(Cb%G@ z4yt|02aX5V;Iq{&1; z9Jyqg>3L#P`=QUhq_~&{F44s)0ZCR{0k<-NIz*#X5fi@mVXG6JJ_F;B{tG7JuXfrV zFrNSizVe}=q3?={{5Egh`Up?2N9e-}-kE+YMMXUkiIG7<2mA01!g&U`@!HsksG-+>w#I5^0?EiFBY)E)-|i3>AG$}88ezq)Mc z(loT(QzgKehmgXr7Y-LvxU$M5=cbF|iO(zV#>M3$`dSDlI-lUv5)=_sDf%>vkaUDW z**t|dIcKQjsloQ&4{VFSMsYoI^k`LVrosUyK#Fy!#`|{fE)cLtLSMn*LaU*jZm%2% zi$01_rdeNKUx;imTId(F_iC)HXQewZGXzL}2tqL3lN+-4?@CJU6*PNu?}$<~LkW8K z>C?r|ol$djC)+6dj+WNeFEEg=A>}Y@#*BJ}n~_jtUm~57hpvAO*!od=x*5czq?DAf z&N3Z-UiN7xA&t5Ql&9d_i@PZ)9|RXHcxFY@JOYeg&CMkO7Hv2j(qpU0o zk)VF}Ag<6CM* zBjfjI8VaIvqi}$~KQrS&Vj>BV7&h7WsCdQFr5R_kfahI@{@e=;3Of6z+E@d^8FKGb zJ;4jpkCqBUN_aGJ;~t}Z{MZPx7%`mJ^h7TD<=>W690JwSVhI9;yZ-Qji$VGi5+y7Q z+zcDi)YM@xV__Wdfu$Bgw99uMx2Yoad_Tr>C{F_Sr5-}h)wRcGqovc^avvK!N?sI@ za9Vo07Xm1lQ{%>;atb7VXn;OL=%)9MMo)tTZ{N0F4*P_xnUj+f$)_lMDp<(yzM_W( zaR3t?3x$cagMv4Z?v3O#L07{+@Y9|DWJX`Ud6T2AX$iaQlQD=e49}8qk*C$#K*K1F z&@E4-yWvn0AdUj`y$~S%*iVO@p5k2y%SW^8KAdbxq10e`*ll4h!vlU)wWyzz*q=qg zu^1;FAM4MB(4>uc5TIK9@83GF-IUir3x$2?EnDog)apV+get;bH%?r3$|!k^)S&&Z zcdGbts6mE(N0h^{_O(I3 z=Evsgp&=oe!&s+uZU6>&p@uV2a&XU=A9p~qpjjeSwxKpQLuCrX$|Gj|5-A%RxP-9@ z7XMf1qy1&f$03J`ys)PVtZ8FmjMw z{k>EW6XA@PwY9lL|A3U&u3M+n|G4yX?f36D4fl2IN5egX*+eXeQmbLavuK3G90R21 zA#Wuno(Q*6VfKV=O^8~(p3Hpx|1$lsw+|cQ!J2*IC#}O$8a)%mi8d6Wa z4JKG7TN)Ihc}=GmJqaV59a%31Mw039IjF9P?FgM4)^v!5DTcHaoqB<^ta;O$%k<$` z_V``G;20~2QSZZ!Ah8}Z9W>|5AUqI=F`!eCeBX2279ha-eU}G~BGF-0cxrV&oNC*< zHvEwyJ@T2oBm_(j$R;@j$5l@P#3~GOc~8&}=@sB>SQFTabW#UWbyqvjAGn{AQjD`9 z5XJKb{)hv|L_Bf>RxxolTzvCj z6E-DeBUnqgWqNp!-w7*Y?y1Io*lOFg)vPGJ^f$l-h^>YLECT1{K@HrhBq<$#cF`56 zp|~W&ZF{O&8iUfJ6g#{oUPvUM0ik#_QN$uXTCO{ubNJAqI&eQ)K}cG5VWH9~DCmAh zJ4D6W;fQ--TAWr8G-R$)<{dgVdtiCOv!X4H)1`g~g+BJ!J;lB>(L`tkVMmMOjo<`C z*MMnte;hJ^;_1938vZ~Cf#ygNC>H8aU37atjx9pOZ91InfuSLD2nXnBi9ioIw$V@~ z%y1^$4<63rjwqV6%Xnt`AuB}3B@A-iU*+*>k;_D5JSYku5*N+G&##RJ7p~J`f9e#S z6{TWmxByA=0*vN&!59<=@j=vh#^V0QJ6Eq=BmNK~OS8~G^P8McWkjVUB>eW1-_r47 z2Z%6nqsa^p13S0n{_9N)Pv=RVXZ#4SF(1etQWQHEmp>S0YBvc<_#kq^ur$+;e_BGE z3jjW=SaWC|I1N^l1!_K^X7y7Wk>m^&=f{vC7T~BNC7S7}9UtQd-QG0%adFF}n059R zQg;j(1K{|y>a!O2gMHzUJQ}^5#>_-s2KqE43P{X)r*;?zL!hS#MT+0ifpEAEBJoql zfWf_d<5;C4dHdeE(9j}7n{3)CILweHs4Wn9QzQ==KZTLmWgygIwGL5(l07X7~;09c_BNA);I&A zD5M_oDF6=2BiZ6?8HmU^QFF?erlb{&cUjkD1tCS&04_u0R?p?QKDwYmiR0F2UKl4m z;II(n{GJ)2TjF^>8^zHgfnw_ZrU-%h%;U3fgn&MTpqq1|)E?xcwUoIy$_hd~oB z!7xM&aw+gH9Suv}FqcY4{-Bppl?B>G_?nKH(9ry|<=t2kGQPNct0i6dOlWw&1Rp_8 z!qnwAakFtJ=J5w_YvoeE6Z{}A6UzwN8NpmOb@hTOy~Ao7o6rgg&p^4sW5J-HC(I&q zSaYrc|CUebz8+u}c3|-kgnpu+oPkFR;ei5U*yv`+ER(j1^90K+Qsx7Xl1>O}h{N*& zAu88F`oVkj&d6AcPJncn52QK^3<4g!a7= zYH`>5$i&l;|EorLw^ZiOuK!gZ3?EefHFr|FI^QuD87?wPdz#+jj1`*8hI7b;@a(qh zYoS+cqwsC5nd4UoC5UNK@PTd>>kQdAFVF=7zX}R3^dIPhwS@_9I)_dTon!_QtOdCE z^h2*_!*I+lzRr`=mr>K7^0BPU6M9e{x)Bq&3!#3 zt5QuPS@qy^KA1SIC!%F1G5W_o8ghhq>gmbA0Jj=SE|dzIzCzZV3F2^$x@$WUSU?p6 zEF@{;F+!yZ!iJ?mR25Ff&kC4?DC`Pu)`q^(T;m@PiI66b)>NgVLIDgKAK1=P=c5Dyyh zdi>bIBx>AiQjk6!3SNT7^AkM~(~Mj+BSqy2svsU;qe7N7j`9n`uhj$266U~~q61VZ zTa5N(^>{p2^8F`7c41+pL7)T{`MZw z!iUldTS$fb??Tx>D~kmXpr=WD7`$|3Gg>5q^$enjr0-H<14l_BTTq>&*p{e3T& z2BHrplVJGF0uv=0YJt3U+vPb;-A!oo#TYLOg8e~1=37e{rlW((bD$Pe8>7 zT?UCma3I#4f|j`(KMhL(?E$&9xOFyQU}0R zGDWj^n%P%TIoY`8PHU>O3@TC98%a?V}9+mFy zbQ!0t9{Hz>7yG@ClZ>W4>5kQF^e{C!nG==+#90J|NnypHpx^cD2XfmtTOT{70{(=a zNvF7AG6q?AQ6v2c@wZ5qNv ziSN$QI0jGyu@`xPFd$P3L1bj~J{w;r*#}KzRT$PhD{v$QH4F`JoLDF;BU9J$i9J1dxG-fQvN4Ia$eqy&HSJ(8oxr4)j04 zmBL=4Gj+jw6H-#F``4pGuM%7wm0kP&D#bYP_Z?#}#7qQ4{+yb6-WFs{uHU#ZA0?aY z8uZOtvAzW~|BLf~P#D8ez55boa429EOG*Y{5k9@~a(Ab~pF}LYXSZ`xQn*0X5|WcO zu@(S&sgxkBL3vz!pHY0(qpx58*+Ah5t$AYw`HN%Lz zi^5BgwJEm+X`rmb{e5<4`>F+1`#N0=TeIbr@76d0<#$ikEuCS=%ysSUp*Vf(Kyc>t zFJSeg1A~CZ0KDP$&?(e#OaV4O9o+{n2aAe{K`;&>S-5(Lpr~qVPlx4$h%YLx5^~t^ z7hl;YLsiKVpW4n(kiQ5)ejmG%QX94P=Z{uYRaqcHhUcjTpC3n!CG_6{|CoFj$G^Sk z%n9ac?)&^-767^vV7$7Tns=w|tK6GPZh|<`TLm@}YWHiW^}zcB{qpZGsN-AD?*q>z zTmrnY`&6y^Dj1I#y`ys|2DtoS2Xm`VF82e^Z~`1CjH!)Ht<_;;5D2g^syc9hkkDjh zoaz0|3xpVemPoY#?7QsKCpz$oQHO$_hZtjbxweSezqT*cINlH&FO!-cKftj+dI9h{ z1Kt&bM(vR*COHB@U;E(zUtf}W=;UC;8)%Y-La8KG@|(Caq1w{$1r167@lc08^oj?9 zEPU>?ZyzGBUKN1zWLux_XT9Pg?xl3f<311+8tR9n8i35lRZX{$OrpUApmj>3fVPvf zfvrS62I~>m|EGKQ1Y;%{#(6sStO98ijM* z3Ni6Vxejowe2k+|+7S;J=goxSUkwnenxrIu-RL5MkLF=nO?j`7kj67btrGceWlF8GxT|1kq1W*8)TnNE5~6 zk@W@}21aLs;f>$`Cr86;Sdh+AQ>%XqL~D?%=Xa9+4_WUW*K_~=f4}YQ5HdoDWMpK9 zNEw+WdxWGxMiC`4DoG;Bic*AxM52?*jzSV5qcmhSky7fqAMyEJx8HUB@%?>&-}5}H z_xtsFK9BKuJdVeKG#&hhf%z?OpkB6#MF+o1p`cHe;s_z@+mS>tf}lHba90-Dr-lN0 zv=c&alu%+>Mm7+SSL#@ZS{xHp`0&_ypAhi?r71kRt+9MFu!s@2D`EWU?%AN1?!3 zT{MGe@l;VT@QLPrD?n0DX5yeAWNE|`)t*0dih;q&cebS1V`t;Ttn#C0O`rZXsz0yw z|3oZ5Np%zVUOxg~K?{t7!>cdRBoPO*)VEoI0RitnerLu+A=yHjLQ*`~PCPGqFUE>_ zmaL_qN*45=uS$+}^82zj4A7a(vhIylLlW_bcK(5?@4`(NxIz)s*0ZlP*J+c>HEk-{;>4e*K;hdkj z^OvP+rtcPlO0tY(bLP=-zZ`3A-GeMM_bnPmJRIuv?tQ+`s-yB_<`w@~#xz8lb%BB* zL-e8WNHkUdONb)%L|JIaLy=U7l`p9-LO zkW?LpU%NM%@|U7jXJh2EP^ENYn=Sf7%h&A(P=7jWw;F|K*DbKkOd--pa3Za5@j#s)K@G+TmX~|Nm5L zAp%E9ecn8g3sIGvK%@tz$JwM#wkbNc;U(}E#bIiw9rBB( z`RSe?HHOnuh#-ldCT@?JIrBi+(3B}RhJwX#xb#a{ zxb!e3p%3#H>NLyX#6PVVa3#9N@$(ZEa{V|HoS|o8{wb>)M2gMng`71;h)7dK4YpW_EV;)bdAU8IoFFqCJbx7QubLB>iz zXfdi;!C!m!l=%Sy;_5wMT(vo@G6@Sp>O3n{FX*qZ?AR=x5~`s)&>0j%5*vPgjO#|c z$BN=MBf1R;+av@W?)DX2{O?`Zl-i{$w&SomI?$%Q`mtF^;RyT4a=TDXF%C69^Zn7g zdj5}?(^s_(nE=m~GX&{10=?S-}L-T^{(@&8zZ8r z3ku3W(S+R&+I#+DLpN?Pt1?E`NkhV3O@h9+=D z;xSBLBF?cg*gtMk?bLY{V9{bzA=Y0L_IDFip@`|z7yoopJEnv#ra8P--om;v_Dj1F zuso%TD`3BS;NuC--~Y(>S+-1^8Q)g&$me%1U7;^RPS{%MA?4woJv;oRXQW#{ao(iz zvD@AM@xd<@*KeIF+t_gUrlfUr1N>^yC2js5N1p$acYWeNuu8gY=U?yE%P|s|0Hlfw zLOA`dHg^vNvn#_^(n>@82m%7?aS<^BU#%G;yAQf|M~0thQRA7BVgZId?fLLX2UomM zoj!MN0|kfUgOmN6wp)3#qFaNmDC9z^@r?KS`@hN5EiWio_1&_b)zF=}nA~Ac_aJuo z*6x1;wqp#nR0IYkXa~h{6dq|iBVDv^=XW%rplS+LyaOdA_otJx(#3UOXCio(5JpbC z$?ZU!+(5?vQL)OUOJDqJqV|AhozB;ODj8ZZC9rsLXT)4m#x{=~d%WQ4c`Rm;am%o= zU@0;`#{a30IjPgT38zJ%4(W;`!x$SIEszFr@C3A$QPrC%Wh$JBMN5~uB6u?w#2XNf zVStVH=FR?oqt9(Q>`GX)6B)6fYbw1g1lwwS`>3p(zBfHHMP{31O%ciu7O_g09dKCiJJHKhIH=JOxdg>B%DgItL(j99;eii(@Y z&jZO;{}RbpWNw*=h(x>4VWhJXCyRk;u`7Ui8XMUDy)*cd1X&T!UNDOj`%0-?SH=Aq z1X7+JG_19XN(PEFX^;i&Buj|p9>S@2(`pr;UAV6E&G#3ZkKzVaZ<#=14FX7eLRi^G z@c3uVTRk6-@&UtY|HgA&f7B*p&@BrsMtA~2l#vM}qE!1}yfv0BTlQ~ERb2ECbbePW ziTfV`a7T3v1r+@G4&*(u{0kWwCaw764-~UQ3a%ds^?ySMZb2JKXD*6oabDqeqMcZ5 zX}JSwbIgxDw~%a#I!LHUhrG4|fl%SK<`xy~-`(ZUgmK+#R;-siSaWTvkpf~y8dI^; z7ciQ4&KZ#&p2>{$V3+d)+xm_AEr2r6cPF?u9;7HX_%@Um{XiH+`A%wd4+*iD`YGr1 z-(Xbn5Sr_+nPd^3b&^)7IK@g0>0e)`A67EbBbpJ!8|fcvZaA_6@5C+uicro1#EVw| zaY6Qm{ari%G!jF~ls z0^-e!RE2s=w$X9qdhaVkQCo7Tpu74zxW@exOYkliIGFs2cWL#CyU0i>xjUve{FlfF z0IP^uD|u07!Q@0k8^J0lriL%(z_1W+bC|_mf!V0wCro%a%Ukx5QSS=ZM-7YrZgftx zT-X0El_sYFlz~u@X8Uz1keN&l0ec%DDxg~^sw^+K^W@2eaZPf%EjU4#i?z}adwM_u zo@Pz(@3$cu zTdegrEPODd-sG>zoB=>nt2^ys&#%2NhGrm*t=YMr6TK@-z6(?f5dpt>Md4bj?{O}s z{qA2&eMzl!@}%o^a@6Ybos>b$c?k}bl7hc)2XLACf?~I6^V8#XUc0t!Mf$w5G?qwC z?1==d~Us4)u9H#Q7rO>qUS*Jv9|mbBH(lRGW})q?%95T zg|rRu^j1?N0qG@z94JP)Yg<%u;*qem+2qHaSr%0{s z=f#|;YOg{DZ@IYAn=)Mmj;L+*s|H!qtj|(jb8Jn7MQR8?fVFW%{ls^&vtKnuMV2 zfO;_9r4-m1j9HUr#7B*Y=E^~8oL$3pM1&zy^cnk|n&~g30UZwGR}Y|r zl0ROCXZft_eiRJ&mq|y8?wlwA#--f6x&Ffu2pqr2&JJeIBvXiem~etbC_(583Li}L zWDNttJi);bH#p-g$+!5R+w1mzN_h&}pVu#yi+!&%j)pQCL{R^bm)Cf~f_JTBzO72m zSMsKDSI>T(9pIE-)*Vs<8Z?uSJ(lWCY{>w-#LHYJQ}Bl>ZQ`@`8IeFNJ&B^i`}0^g zg-^w=^o9}*D)DpOL`U)!K$Adts1^SUd31qC@=s~Ma^Cu5iBSog)&48Ld~+~A!Jfq| zU{FCrWfuzy`qr`D|6X-8h!|!c`a}}WFLi8|Zr9>QNHtg?B()NVZ#<7Cy5lEIibTz# zYfxNM_8-V@Mk-a_aV;8j=N&)h3e-G#^7+fD>T!{nvr>I!>Q$9BC5T?<^Ic?VA2(kg z{oI@XzRr)DQS$ZayFj;qCD@`MmAi#`s|+dgS@qVtv<;RSiM@S(X56YpafUrX4UiQk zPMRZ?lgV02TK>USIftN-cc>joo9wPggiedVv8bZrdy=>xrGNP0BoaUfa&hoEx8VAL zg4GL=!6&Z9nu|W>SJEGnH_tu9{?#+ z8Jy7SAqmO?!9Kc8I;5bo;+qw#b*=%{wPVl7-%5~dA=#A!9UtaARQhZuIyqT8#^0}Q zDy2BLE(8XP)y zObwYl&moG8QFjZ0#=GDB*;JGpbC0c8RYWo3)~ZE|J8(`68l=49Exl$TXFOG-EPcCt z>CzJT&W{OY+54xyqG3BsdU%7%6yVcb))7oMHeO6K^fvwM{{;HJ8{sxKCt^eKMAe*; zqDvg_0W@hdi6KG5VvXLa^+-=mJvbTYh?Lj&zG_bz022BnmL9ybf2eBC^x_Ie(B5WY zy>SU0#QHN+9xpU?7?-I>Z&vFjV#A~uCX2StnLBsn;7W?VOOWoDsO|5onu853Q_SX& z>`2Hv4{CSV)6;0))PMPRZ>kpN{f*n|cpUckzs%r9>>c$5XQHAG)Tv#&FG8fcTN=0N z@0$1e@(vzzk=oq2LWI zDO@|&y2)Ydxbh9tu1SiEs0>!Vd9y0+F?IB8MDthkQ1&-clw+mV#{7JX3J^k>1<>&E z>Q}rFj*>IsIS50`IqbZ+Lyp%(N0Iu*}b6 zf&SmU?^OX4kDs@1!;G0i=n7Q$n0F;}nLi9$ck-L}(Kso}7;TmAo_<=u85b89vO;7# z{@)?sn0UF}wB<10lEpa+rcK{2cT9H*2Jsz5-O33+AMihfLpDSaTT#)=@F)*Hc1-7Y z4-md#k9iBqP4GXm%os3A{-Lb6va<`W8<_ftVK1mZ5QJ|p!rFlbE@oq!U{$;~nQZFW zGi-_)-4~>Vw$W@J3#{gg{7Wl&1K^RiYixggedfbg-)!H!qW}I{RL>%L2j45r*xnRH zPUY<~r2u9GDsErWb*hBgl3^cNJ%z23bc=xW&+}yy0}oVTe(v%2SAGTU(#g1eol6S` zRh@eFSI6pTfu2|de0|xIT)TGdX?E#*nB2Ju(*>>}>Yu)lfP#FWPGmR1XlLi)>FOnI zfPQ87EV=oYNsALdRd{C7_A*Z;Mb@0l%TQ{B&NCN9JgjrtZf$xYc(wBZ2(#Ks2v`gJ}`GM$j{NbLQS{#M?5XW3yCA_P6u9G5KeuF8i={(~A*#0k|Y35A>` zi^C9=$rx=iPEG4QV&3y@)G2bX9B5TlVj7!NkTb)iEs4xOz`;HM&HZ z+*sBHPl_TZ;oX@dgil?YEX{7;kNx<*})?c;@$^Jml72Eec~&q!{-Y7?aXpT5-5 zTCyY}rRwo84E1fB?C)v-^e7W#&^%mt@${o;mX+E<=pe7D9^<||Yu~|x@fdZ;${a2} zs@SWKzuIlQB+6$bWzv^|^btugbf~F7uTrBhQvLWG`!V+~kNM(%b%bum(eOO6QDtjj zz+s{qDrEdl49XGqDn=pp*p&)kHRo-qEhV2;srQ(-Gx|Aq_u9EMP&Zp2MnawUC zI_WxB%IY4m0j#<8_`UgcMtx1Xjnk8W@$*@z%H)!eR{}j_6amqh+FoYxJ zhKm^(<;0btr)w(acH1L`ueK%g8;MFJt|5C&K%$4VG<<-lVmRloEUoNQ9E6LZr z5ca#Os%m$SG0l8;>$Yq;(C_XsO{*rWHI78L{-}BW+>iZ!)}dCRhc{Yi^|`xq$&_Fo`TE53hP>w2P0~lOcfVY|{>5e68Z$#PCm=2@}0;$-8z{$bwRw3?5^_ z9MGmx^KK$Nj5&!7<+ms25_@v7D%nt;ceUSu0n>FC9xg_)FaX&Zp7Dnf{)n7C==JM5 z*gpkeiEWcqx1sS7>Z zI)qOqFH1TB9h>JKl%vr9GNKV}m*bh%EYXX#FKa+F%u%mTKx_dPn3<*fO6PGvWo=Gh!O44_j|3)ZahjFF?72&MTm#X0YVXd_#Cv?{2r5h z!w4s*uoyHf&Drxp#1a|DK%3`_;LK2u&VOQ5wH?kIr z@Pj}B2o4aQJ@@Xab({`UhHe=GtWQtF(M5K2!WJ}=0ovFn-1J+4?&MBd$2=Sb#$$k za^&V+mHmQfTec%WC#d)T_PZmpK(R_=)H0E}0|DJlX0@4Ql>druA+4F4=2gllG0IL# z+QVTtx3YQw!HcBp{_EG#nlshwRG&GQ-n3Hu+-8OuMPhXQ`t>v)SIw@vy8aaZmuL~F z=BMC6B49pJ?h~9h-uO?vHt$g2y^3?ulbV51Pmr`^Sra>AgvC-;3@pNOB1P$X1P=H^+Mb7TH~4i)Kz+O4`Fl%z~LS4@`Z5B@ESoKnBUxl*uVyR0GI7xy+AvAAb2mU9T*E|-YQHlrY? z9OkQgP6n^x;dUM};HWg5$6XZIiP}SuB_Zi z_e=0wTsvlbc?3R|eDJ*IghkeNvt2vsl4FcVe_H~nP8 z*LFx?$%uuU9WG*b81;=)9|a_(-RTuR6@%D;EEZSuqtEa~!y=(56Jb?YXxh!84bS9T@K5BlDbEf})#n!ga#d#Y?SFc$92`qf2sLPqMywmMd$aCKR; zdi6BjSWQdVFTf_LqOc@cL$cR5%Z1!MeR>@Kk@foN={B9+B2GDQDTW6vm{n1~`le@HBLt21>Tc z{JK_zD+Ts9R*9IB{|ucGcAx~qlE%@_<10dd8<-_S1(-uzdV78S)OndGZ6=HIi)Y?v z?V?crQ+dXG0Jy@F#WO1`tD~TYrwyjzvgB3%M@s6*CWBRi4Je{6^LcrvR2e65@{;KK z@ng5Dv7SD`nrLK3+PnXh2QhBk{v$`uZaUAbIr!r#IJ@WP=IjUGGYOm7o0^Vicaxi& ze`uOF(Gv<~Jl`2>v0R$`wB}HYV<=)dGikL96lA*7SjHuJHL)h&SVzx{y*B<mK}xOROx{25knK3^zpT%xEjNs8{O_Ib!|w`gy?&!c zOY!F7T$*uPe4UuBu_Ub1k|HKDL@pqo8|JRRrD2a^m{jP#nNo0)k}v-)?swh_HBE|AGu4uFnrn#43;YdUvk@WjGPSQDwgz&TY} zuSDRPp&Ovtt!iz_FxW(%D{3F^NlL5C({AO~*6j7v0F{MJ;GfgVYw9H33>?w>t#;Pu z8g6l)$v(WX$x7;;yZ-*@@Zz68E!duhc*uicy@cM!U8hZ;xTOtUMx!tL_>!$~ z>l_RRe4JUW{t<_igEi}XK6`AG@bhsvAe7YxV4`V`RIy!<>$VM-QY)i&ViTs*&r zWv z8P`{X-ljTnn8hBY)EYpSEDziCxMlc*xJI>R2gD|EC+Q9GpF& zI<_ZxQmc>M)8R3mNHPLS_?}ML6|7SFJ=+<0xm%w;Q*>KYfv{SmYof$f))@2m0ki_< z6`Owgetg7EV-inN(D&7M=~E8mMA^AKu~No$*RC~{zgPPAwi{gsjCsm7Y*N5bWFXa5 zD}S$1sr~D8a1^?Urw9IksQbg@omDedGLHOPl!d&eRHw^oM15?|H#5C3e~!GW{+e_; z;)BHXfDWE8emp-9kYh|ObEQiI^-A5p_t1JEFbG8T9VpC4-09u}avG|88ZciWg)gN` zCf^ao)ibI_sjw*aB+1J+uJZnS!XnueXaVJg!uAqsC`2CNgaU)1U{t~`@f32&HsW)F z0X9Z954Y5)wNy1u+2Y^*)FEL8yHr)m(FQdA+jc0oyqmJTq*l$E^5dlR=NA_E^DZ)T zattYXiBdBt>NCs!Jp@C9n`A0Z3eI<<7zd|Ib3Jo2po0~qes|HLLwX@YszrN4OqGl( z-@xtf%Qo81Tk3~!{maYq)qLBPD>Hc6`c{aOS|}^uB&$ZR{!o)4NLggSuV5SP6r$vF zZ%x;|)kWT!RTMuAO1kk8FEJTFx%Prjpqzwn=Y8poE?YK*+%pYdc#QwzS)7Xt*kHEh zA>}VVe}7&B4J3*5G8T5S(+2}*$z`q^da#fP>|uo1l}YEebg2PS;v(q6J9la^kjtwy z_TdNx4^Mw>32wU~#ui8r0h zc>$p2=u0idJhS{C8X9O!7Jg!?Oco%68_=j!hW$h%Lbw_0r!|9|o4WbW4|Wf@L0^L( zz!=yBqRVJibYNHWu64{jinIA3M@MWtAl)ztqgsliNpkw0&@+76dz1 z;X%JB8U#Y+3(Yud+Qal_?_Rwk6D#w6_23Ny+mU-&9IQc`3Wkt(i6F$pa^TP{)2`Ue zkT0{~`XH*dlN6lK$tq9nM~sMZ`4iLpo)OW-Vh$w)S*shiT+n;=Ab`>r;B3sMZ+{_H0$G_p*UO-?AQw98B2$OsZoC)9qWgf|R1BcobU`+z?J3 z=A24?J8K#$h=Z%9LzV7?Ks0hdeD{z#fO(^2dG1}R&*s%=3`Y^?yLA}6>b=208my zgC=Mo2M~t;+qZKL1{r$>WMEa1!61&bp-l5LVe-^U2jeJ{(^J%r=vZ%~a)G`KqKBcm zxcsR7xeaYdtVDSGU-=7Q26lRRb){Q^ER@+EmU4dt@C#vkLfSaWjvNP1jfwIl-GVh4 zAoc)yxBqav&i??l{!5jv*t{^&?NAu6eVdJ?JGrdQQOqK(BFT&40Oj@>DufqYIuR$c zy7InEOdULUP!eviDdKnh_V$u=S5u$?cUsX4A{e`mTNv&+zOPmnQi#K_$d0En)`Zk= z+O#|J2u?GQ=4j|5oD)vL*yyZ$tBP=^`NJ7$?3`@IsTx1tqh!@RvE`GaAIKwcQL@iEBt)Zn*Vvuy7&4fz zT)FV%S6%d%003D`#Yjs4=PqvvxDc=a?M})W<1W!3D>STi+VU#VB79`b28`Vua9 zfGTj(bC?%64wTP(KC5n%=@h%fnQA=2`)fJ&VhGYSDLsv|v9-T;&Nmfl6FsAI?yLVMT&sDG!rjO2&PSE-| zCdwlOS$71ZkGOP6>s0Tvudpgeq6UK=X(YrB3Ob=iU~o{)A{2K&`mU-#o^xB^hzu)IZgMa3szmX#Iv36D%VV}qOjKaxmQed4=CU3OocF2?~gCUV}DeT zz`%1ZEZfye-(%kaGB@XOC_E`&1bORN-JWqMt600VA^+q$LbBTg#$V(nsr6*Ay4dE@Vi%_KBhU%U#~ev`x@%t>=L?sIgwDNnXRacr7flWPoYwV3VrUawQv-@o~V<6 zY0=k-eiD?ISkd#@P}PJU6l}hAi7?FkA4BU<%#{`3+&AoUNsc47r+^z zz});*Kw%o6C`1J%k;9XjdAnXm=TUK+|75@anj_PIvIH z0#E85abQYJoY>^z0eg@(Mk=<76LPZEzkcIDqIRVVE$*}w)Rl)Zp%x&F`EZ+f;~7*J z4C8Xh>>*hW51rxb#K0fT<`LS@%eWLDcAKN5ZuDSlt$JeJ>*VBwqnTKjKJ2=pk`zYS)y#TN7A*hQ`}VO?PJA5dGn^ zfD$m~x=CwDIf~z28~RXsB68l9F@?J8z8H`zX<+x-nbkl6(Vw0N4>c(#7{kB}ED)8% zl@p;;o@6u(5@jE-l>AH3@PlTPTrROFSm;=)t#Pz{FTA@LsG}-eN(jSH-j~uswwXy2 zW#A?i9x3=56@V_9bo&5J%y6URZ{Lr6A`aawn!OXz6+l<_k%`@dWt;ai?t3Nn7prD`PYm8q_$a+-P>gUG>j ztq8>?M7P%WXl}<0jcib-(g6WGXr~>Jh!HA0a4|G0JF5-s>@KDGm_m|xG>@XT2MLxD zoEP3EHZMY_?~tk;&UNWtpJ~(4K=8B~VfFvd@c0xJ2`{)oLK$vcaZeqF(qx$rcozhrxdi$dtN?(yB*ap6g3M7JGR|D zHgCMf6lw>JGejW@3b`=VnD+FuBB+AF`g7RKUEkN2m-CF>8Wda7z>u7z7xidhf&H`q zaXh-kD_34{IO_5v`(X=6`+1+T?*h%v#`;$rKv5>9r?V} z>Xqj0+fU+BJonb%MJJGk#F&eMqcNfun|Mcc5gGD*dPJf!bhuHTf8FhXh@ALjZUkv* z>ls_UO^jkjU~zJ=p+=kNx3o9S&^JpY;V~@88=@hVv&JXzB-5~&lM`+?qra}Q++;puv%b8ir&+xpbpSyZb*SWOszv@lc2oSp( z5RkW+QZwQoQ-PcS&g5e@hUg&Q)IQ#Oz|?}zj0fK*8ujbnKbYr`wr+mh=3|hCSy@?Q zxT~LOjw4n~q*IrLT=W*b4)c#-qO`aU0%YP( z_N))fQfqVKP*;q*j$zSujzE91b?e_NuwrgIcxA<-Vww@^-eawwly)w60F79LU6L>g z=>4P{2K8|S0h4KOX@jW?QZ8Fg#qrZn(0*E9c0bZHZATPAhnDu|cAbW;jwf3QXGoib zU4vNW?DO|;DBKtrxH*`c_KgvSlc!GIv;Mu~4mMFR7IRiW2^T%KaQGMY3e9@ zIrh?`TQvu@QFtYv=!(@axI4dOD5;0$Fs`S>Os)Wb)QmIAOTT!xkflABAG z?;d-H7YBDYG1l?QlI z6IZ?33~&cgIT0S7MEAA<87v^b;yC1SMS9hrjs)tLEA45)B&qR1myx-d{?9oaeUdBW zg{uhO4#|Be4`zp6yAjO%DldKJnXiREtI9O=J*s$*vPKiOR0Hv_cU{0MHKFyuV+Jx>J>6V$*2!@W= z7Q8WHpsK7#K#kxPvzK@ibo%r!lY&h?n{=tHi7Ex4((yU!)YW4&?j-EmC163aQT%* zBKLS6rLyC6y8r2eYNoYG8XLSRP{<*O=~Mw0FnjgqxY_Z-X`Ulfi-nlM3lD&t6cfnwYTpwbZGSKVt4f4$yU=;>R@r!dNZeOBzabQo$WJ9$4I?zfMV=Y0|}iXOKS1=^_1n=2=_ zejofXFYhtI_%&aMjzyofOlY91S8UUg@xjwlyLamroNUF^AkEGp>Xpi@VW@O(5sZaD z^jW&uXVZ0}P7RleDHQ{lfg%_Y`Fln>(^)XnFP2yr*M5FxIkJFS+!C-eZF?@Sic%+B zDe7Y!U@1NYrysrD8KepDSCgN`a@G|t2%a1(zD{_$P~R!w4)660zoE~e0z+@erGGJ! zyR&e^2!J+lnB%jfuxa(;KLu7to2vC=z3^d=GJadqClGNyxusexS)xxF%9WKP1@Xv? z!OzZmwSNED2=T7s$9)@s9VME28Es)NgGduN{1C&-Mfi#C0KwDDffH#3K0gm_0daiy z)vIey3xCjk{IPglN9cbV)eICdF6Cv^XxZd2>Ann)ln0jN1$dV_zkm8uFK#erjiy`{ z939X$d%|)&X{{Q@2;08))6=aeGoRAl(*f;T)U)zB#TzvDF4PWb#ztQAw`*&u7#gGX zzYBGM_1_`7wdF|{H##{9-X&EPJIYxI-d$7E15}QG8xJIc`Fbs~;}T*;^e0fqLoPaG6DxPH<{bifvK%H0ONccA-*cxyw^y@Zf{A`<$=VqK{x=uuslH@?EH)1D`%U z;D0^$u353Bm7b1{F99^=%JNxx#i0Boq@Z{rnye-;_I2s?3nl=EP!BlymUA}~x~hDC zx%|qjG@?vEGigrU;C6t80sEjOk-$VIjx7H+Kn&RMxt;_vE7sg@(6mU`k2wt2wbhYH z7ly3;_R0q>{ZU%n){fS;>9He#aF+5}Sa9Vh{eYU~!T;9HU!yu?bti;-9k@Q_v#t)CGI3%p zO`WBc44*k8tHn6VNO$P5U`@&b>v4^5oN-CJnwXd<>N5D%yx5gwJL;Up;N)V>Ocf>e z^7r{BR}L=3)k)?j@_PG#_9QYEmq@~r1k@mhIiQn#k{iVdJ>d%egv3oX%)^8e%uAeA zubl8jwh=s^beau=h4k$x4b`z;upQfgsCd(1A+$gw@QP(|%{O$bi04;(&pe)~e=E=aGS_cH}!-j@) zJbv1=y^~I|BFo|~^S-mA?KDIj@o7&py$K>z+SKtE zwZo)eq-o$Q7_E(|x(_ZV8c{Hes>FG}>KCmS=`e1T#9YKJmvKrhs~WGQo^Xip|15UX zMvPdWa4A9@j+%r<=Dmr&ejSEt3v+WeZBz`!$&N)$&Dyu0zvAkdJ|WxCa%$T18wE5W zO34?0^aw{cYkkuEVO-kaj;keXhmr>308VV3GHTSQ(8F6!Mv`(CqXI^qG~4L#25Y{6 z=vUEJ5KYFwm{j9hnP#%any|hUffG=YU{Yafp?7aQsC|cj+G}f9?R-iD(ATiJ`QM9+ zC9c4%fV!Rv_S-nh{nM`gov~jP{2r|%Ae<3634t;zQ9BNXD=TE#mRa*?v)TZM6MIew z8tJt00`j(suz8>TB54-(BcsOTE7U>7*j)f9+Ceza9RO#%YDCy!Y7>>z@46IH#+ff! zavSOu*8zs?dY^6eU|;c%nYXG$1amh3jm$)$!^+6cHlPLpZSGOjXexlW5Q9|3L(mS| zrbQa}-gRVYt4+o>prXapz(r}x!xzI4aWD2TrVfbJ6>f(FBn?#m8To-=*c}L8Eb6*; z_a(H+G71sVg#du7gJMkFdA{5NZB$d%r*aQx2IbGus`Tf)W@TsJCDftdT?F1~lJACy zK)QcAET+{CEsSx(5%h$^Ns}O*Z*OKmERxAtdzL^fG1WEifGsb`H;otgP2_`By0Z^F z7+4x?3RRm!6oRU?qdbP|`b_E*BLct_F4tMLhzESqLn6=S2>W?H9B;Ip0VQG1AW5Q~ z%PwiPQ1`r)L;ope5@>~F%K*@Enf{%&=vRG5FwP(W7GjI=dk^xMgJOD0vjMes?*6GG zg9s=5^=HRN*8&{sF}^{pW=kr`ITVr{d0}~oUh=Yt@yAWp`0vhywdZk2ZlER%Z-cS%qVLY-<8-&{+q z2E@3VO8=v*U12HDz0HYV`*#`-jP!!vf>d`hW5{dl?8J&z{AXpVN{~9v*nu~8O z#eoEvsMQ95w_2b$D-%pDGPS-MP#MtGnRaJfTdJrO;s_YA_Opoyb3liAAx06@Cn6Yy zj^xq%scfWmy-6J>vpXE#u_uyct#Uucs1M&ceN=2B1t;MkBA=I;R+Ja>&vy5ox%KF+ z)*9U@Icb25;bVF74?*J@Fq4J4&~V}U2R5>;sh#YjrWlvIP1j>HPOBf2{MBn1;;I5@ z6^x==C;1&d{E!SZi6R{Ur31nB@6$?2O|?W?E3(L6?>FwDaW%Q_U<+I|arW#(X+;Lj zgs_G552oA!TmDWBDY{Nf zkO<$OSVO>gf@D^1L>!9&Iig#A%j1L}X6?r#6vo1i!0Pq7n!2BWw37r&zk#P)uQW&%=<;ORO|&y47?XUnEh^5&+4Sim0OC1enI&5;cLN{*h3`NTn^t5rkP+Y5 zvXAYsU%LrM=9uF*3*U4s1jglA8D@egz^J*SJ}AP<2wA@Y-4sBeQ5!>JK_3B0G^lX_ zC`HvDeaeI{(9nL}It!tKoql-m?`5qkJs0q22%Leq_8K{LvSwA-BA8;y`PY!h0?&3&P zM-x%H$+vrE|2dcSCj$t00PA#w)+=$K14>;ZQ%E6+^L&S+qBTGT#WaXA3S6^SFSj%IC^MhdS8(Lpvzk;uRA*s;mv1=YbT+tXz1U!q-U zf{KP`YXOvfqahsb;uA^Lu29o$<&qz zQo&?empK`hk-O(btyl~kBtr^Jg!gC2wExgJ4wZ)|vUa%`yk*uKG4QsH*Me$JL>8Yu zNusxTd2Rw<@{EYe9eL2A+NK!Ed%QuNXi6qrQ}BKSsB*&*`R`*UvM58rMG7XSfL?e| zOl4+gyE3Map2pO%p_WdM(#(4>*s_^a^pd|z@)EK5U)tQuM3`_O@zt~|gsV}+I%#87 zRi`1A%k#;hq#|050wzY2dkhsE+T93=+C>PH?_iY*|L(ij)%B%T-W50NeKy^5f)H^ z;PxY$qY)z(T<=A-jjsSz0$^k(x_8{!^shFLym;|xhm-#kAHi87H})k29N0NDNJ~{7 z+EQ@xdQCUZE2+5zqnUI=hLfKoA3>U3AlnLImW)$U*f%NwpmFhMDimJ6_giTVD3 zfGM#05g&O-$sG(fI9{JcKAQE*Pbl-?6a6>$XEa|(P#OmdvUVIk8dd}_>!qTz`y&qmpPLS zO?Ho!<&Go`Dl-hv#zHWZ6a;!lR`i@YZrMnD0#B;7T(oj!Pqc%M`q$H`{Z zLegeD5Xms)-Divi@dmacpRJD5w233ytnV2hMsY%1g1SXJr*Hov>&0U!l((vEt&l%p=y(>|K@Fe zm_f=Dgl@REW6-<<&=m;9Y!uCP0Lrrl9AwxP)ZLA+ny|WhL`;2`#U2n zJXW8|8T;%aCJF(rgB^5uzD)J$@x!AadmCXb0RXs$NCSWG5eImwKJw3x=_ryQD!Rh! zQ}vF{n=OA)IdkaJ6&7`-a~K&jk+oP@3j|U5RG)*+p24z~Oy;4;FX)9cfc%9VN`P`^ zvZqJ)I&s^;TbhW10Th{Xa3MkhkLqA2*ddhU?_UK|IVANPH`YK1N5mA#xqRRoiZ;P! zTSXm#c9KQ{jD+B{9qJhXh5z$S_wh}Y$q7qY2|~3girXt$ zO6sPkVEfSGraOO^4d-+QdoT(5j_v5#zXw9UV&X6eE1Mn4_j+ROM(TvddPIi@xoa%2 zvIe&f)YV<$1$+vuf@n6#z0-A%$TxN^T}5SdP-GpDjm1pLU=`!>PxGQhevgMvf_*TK zwzCjTpcKDRQ8WMjux8uQ{SD%dmd90<>p`_p0UWT?HmI`}WE15`0!K_LWz=$$4)xtC zb145lwMxGpr8(llB43P&uG91&s2L#rslG0;CL70laV3^Iq2PTCRZzPH3!)u8tKX5M z#+V<8p)ipmxZ~fJQ42r!<}ufRL8m13#FIaORda#@)^#r}>x^Xv(fBfi* z-j~K9;i1rZ~Ge0 zap}Iv_5$*Atei@|?L<&5s(N{}4YC_;9x5r0VoQ)pDtTjFZ{=X65j5=5_n?aaBOz0_ zBEKz#oO^zL9%Hxiv&#Alc(TKdRoo~xTHu_GHX_tCbYGf}K|gBF93)Uu(ev5S^N2kZ zqB{N$P%D`b0{92*u}VL!*?{-&QvUkyT#j{MJJK_66305S!7YsW04WU1Rz4q zJ{`tx$(xU!^s}NTlo46(t#scMDKb1JTF>F?M!QkwN)15Wv^#Moy z{mUPX-X1rvD&;285RC*{R9x&=uaIYGt+a zEZqR*vk%dl^K>g<$q?I$I|6fuy%F+V370n;b+IZX#D=nlCg3|F8qUW zI8x?x2+9at3XyTEyosu>o^X&a#~Vnbp%8}|;Y|^)mzHi2K;vGeOB+<-T3JZ&wIgHo z3a*1{;MR~pGjgR~12TDon1#^I^L_;8?`Ou!7=y|1l&J z;iTS1=jFefVQQ+htkDgp7Mbe?cg5ikcg2*<`&)>AtiTGwD-N?!A>WbVZ%f^w)2AxMM@tGaBZfE@TB<4AP_KBB&(iqm1F?3HVqG6w}OCU z>Vh4Q3<19XJR6f>R;7(~aEQuidkn8IM$0&HCs>zBaU~niaUhk^+M5ubV{a;z-SqSI z?ZkQj8aoVd(NFc~`^Zmi|w}W@(RB|6{ZGJRqUwCv2VF_U%u~ZMdx7jiWiH z7&2p{f{__UjBy;0-Zzx(*T zi~+5&425x)#DSVN<5uH6K&m=}2iH2Eklu4`MspjtELD@G_XrNe z6WqDvwdMTyvQC(stJC|+eps40A75Wr5?L_zorE41T!`&)-6rkDweMCqI*|F}T2H{? zO>CRkIkU)p3=`$3X6huRlzdL9hZ`!i(iV;gMvuo?A-<-#>b~k2ZrYT%aM;Y1;O5zsF+Btq)mcmeVN@>c- zOoMv$>hXNmsQD-t2k;@*pu7S!Y)FE@)3AmtCD;<5C82+taUM1UtB=ksRW;{;sXUr3 z8bQ7xEN^_0>Xs!`Xl@ z*&d&jT$SqLczhnacN^l^gL4C!LIKo(8gPEsRWBX-nr2*G&jGnlWrkB= zJ*Gu3WUZZzwF`UJly3wKcdSWL-pDLD%cQeEZgm`y&&J@@RPb$JwaP_sfD$U^(vO>skwytZ`bx+XCne?bf=4%2>^O6CRT5t4OflBt z$+RD`ddt@#YEQr#p-sCUI`D$!hR9-WG899y%_!QiwzY}Dz`=vN06R18Fd7A{7+~Mn zP*jsBj=zJfBjN$f-E?&)b#w;&uZT&Yx{T+~XB4;bXk*OSM_*p?pq@6Kvj`|}(>(Q~ zc@i^55QF*g%{?h1+7I6#4iU1omwC!Ua^BiQ0}Yg{lM)gW>s)^U46H^qe2>;bHkopD zaMiU}ix@+hC4X!UK7z!cS_=ANnK%%Of)%MR$JE)p5%Kph0gSoy$1S7hJ><_fV>AWu zkqT0oM?sEt#TAw>@u?vCn9Yh62ADJf!OMlDZV_7zPUJ1BD^{~xk@MoFzX5TPuSs?9 z%~?1R9o+`JLkzb$x?_@_wclj22y2H^zMKxjgyTr#m}Pul7*Te5p_H4*}?tEg2@W;aq`A>Nw#SM z*y-cwfyAf~&DBjNe|~2axHqUMu>oTo!n_RpPr74v(U_U!S8xFt_7n$WR2a3x4l%f& ztn;Pmczm!x`0LT=(et&C5hB3QzA#<4zF(rel_kS85o*AKMs;-5gologs35UbU8?rjpv>trJQCcH*rMVUS5 zbqm_!px5g>$|*uD1w*1%=Xp)a0}lT7_>;knxDOODJ3g{z+Yv<_ACo zyr9PUkX;mb9mA!GyjJuIUpKg#Bapm{^h69qhHorsL}@Ckr=XbF7^cLyBwdskA94=n z$7>jzanDs@x{Mih7@P`csJWz6+%1})_LIkN<;1t9nky1%FHR6FT8m4%Vusy&#Ern7* zn=ea`FPQKAPxr^7F}nMGd}`pKC`^dy+qkWS9SK6%8H?f|wluRLcVsc5G1IsEU7n*> zlDI35CgaB|5eQ_LF;@BNFy_1qk4O^9ZSn*MLJnceUsWHzC+Y2oi_?QHac4AQjoOaA z4!e?a%>kihB>~42BW&5gYqBQYn~J_6rMw|EjW~?c{U8gI&A?x+I`1A^_@)g|gt!8t zwK(n8y>iUIWiP;(_*=Eb#bX=qB{gEaZcFZ{c5G=)IUD>AvH6vS0cyLHeN4C*X!fLy zr$vv<$eu?QzTG|0c^gW!#e9PK@#-fRpwZh#`9>L2gi&H9Y3jqU=GGREA3qksvrM9p z5HcvzKfSrCof=`#YG$*A@k41aydyLoJTrmV>sjo|=v*b?_r0xE!Sh&^6-d(gX#=GWSI2f6a z68k@(o~X}5A5=9wtMXt8&x<&9PWROADUP$(#(TMgo7t*1|w5jSKHGrHa#z=OM<#mA=T${E%~9f3@b`oxyI+|UTxhC#14 z-DYJu%WjxmE=>*8|3jHp9Fnl`yuDtMFJ8dEK77;4ULD}Syr>;@5o(_YsgHDY>r)%ENf@H5C?qtV}d+1k+ zI}gRq9pZl4k5fw^>(i~?OeNUE<501mXlzn{&$Vl%>C5hVW-{RMvN3`BHfZG<=4g3L zwY3Tj-*N#iS|)X1#OwIufZom5Igjkf@3{j~Bb6Al?;p^!b+#Yu<9rChbqmRD5tymY zj6mmU5R9bu_uZy1)$2+bw3Qn|`jq4MKyE!rPTb~wwEEY-DmzyY%s|LAeqOIu%hJvT zyjClAw4ugJH6HSlsU2C!PS*N_K#fkI2pzNJ0?aj_U~-3bmVF~s<7>Y>uMZpImr+jT zFM9$ds6zzFEkR2leh)JD0xa8j8?J^ok{vJR#73-xPxu7LWn}LdQJpj8-{n_JEksaplaTT zczutGi76zhK;d|5DTtcYYYp1AWyVqg=Z)$qJ>C138__`wjv{RvmMuakq>6w9KCZ>@ z2%etoOo1|PBzjfJhhR%el@;k1+7;N_Hd0cO#U$L3S_+B)DXo&3xdh~Ikmsz?wJVO_ z6L*bkR_sY#W;$z@IV$v{ACXmyH4QTZHK6fE>+yq)WCt`|C_<5@$JhOyTJ`+bQ0@;I zPRs?Q$^a-)YymvN9aUc0s&xx#=EY`@N+$xn2tyf4mEYFob~D;^2|8OAX?J;yj$MWEz#wlI(<4`(U-gW@$=`06%`e;0dOWxo@}9bMFkw~t(5^$ zp}0uEyY-8-`-(&Fvc6GNrhWlq0<1*VNmYJL1VfV{xgy?gq2{#sH)@g@+ zBjx#X=di4}Rpm4+mO#GS!gqUly}}<=m0zQx(w79puQ@zmhggh4k9X_dJs#al=~&yo z_g_&vA0}udGT-6V@2?x_;Uh;HRGwe;_L`3xY5`2fS?VA*qXbW{q}y6VTOO@T6Er|5;{OW}K7 z&@%YFnYkYe3X%W=>ZE>Wox`bsOf0{dMtWfMMd<$qevGapfAE#{P^~|1rC6sBzJbckujp`W!=K6`A zP(#F%3#KZS1=82UC$2fdPPYGtt}}tkd2QSN9if4QWDLnXk0Dcoge^ouB9$#u%21{z zDVZ{CV+fV4lu|SpqFHP+y9`mul#)!TNPWLE`~B8>zqP(+y=y)1vp03$|NnKJ!*Lwv zan>WeC@ZMdg8{0jU#=6{MH)jjWQV%b=Y(@W%|4*hvEMzIQQ9p7Lr`L}U_?nlqUyV7 z_^(53-N9_NJ#+RK3N}Pj{R8`^ZmlHX*1D~zJ-9=i)>;+{ey9xbQFCvWz<4J=UXp%E z5966^q2mssKC9~`@pvQ;eL@qIo|jkCaij$?k*I6J*vzxxpU3W_!9)EeSOon^k6yhB ziIV8${0kiC_fxJcP8&c?qPSmZ!wxcq0u8FOO#wI5tNL>z@3D_Z;N(d!V6!9J-ZtS^ zu~&;ZbDnB%OskpIj`TZzKDseS=@;I-eoF0}+us-mh zjhXJaE+W^&8ObJVaWF%owEE-B&F^fC|2oDahTf}Fr%nnAmn;AY3v25iR`o^Dqo|pG zKXDk>gbVZTzvsg7-OT-!RnxBftukAullhdGh7*(wSXP#0(rbTBj2d2Z3(d12x7;h# zn<_m&=eA>EJb^}FUm6?xFRyRfm~GIbJwXw*<^1_UfMMO@^r?fz)Lh;wH&}Kq(Vjqo zDOHbXsn0?|z5sr#W8{w`6~t#w$i;C^B3SPSxJScUbcDvzHFXkuYyw;=bIZL+MmOx#d= zE3F1-gT-|zb358vg7Fk!4DpHwvACs2GfURMdU@4q#IN#Xdm@_MCj35{N?D&wpRn%7 zx1Jy*6*-xs6+)CC6ZJW9;)G`N4M>{U zPTJhT(jFLzEM-V$4E4bIBapRQM>7@0!ar1zHsas1+r=D#>s?`Irrhw*MpE6H! zU-64B%XlQKllys(opr%0`&M>{(o5T6T)&;H+94mSUYj*@X4h{PMD}&5RV|FYnM~;1 ztJkD1ZgsXaGxXFO?}?gGjvth5r$_r8ltNc2qec6K(V+*9;N!GwfHh%`SHCh zzbV#qfYa@Nqw%{69P?gZ{ygUKd?+JmqJ{|bgjgX3`jN?T)GQzmVa>Cm{A=`?Gt#gxcK-s3KZm{tZZyZU*XYALnUmfW28Y|}F zy8p+dNlP<-Jd@8}I%c;I-PzN9%2Ket2=RnXMNGk5est{tse!J=ErT6L6XEw(W!BSiKW>;KZ`b@i9MSsCh{@{E<&)2<3icVg; za&Bn?Uhm5KDBRy7ccrFzDrbN0bt+b%kkxK(ixf|ACCUJbV`p8)#tP;Ub1TMsoS<-z zrS46BbO~}cMhwo0%sE*1iIuL5hsuZ!#nfy|%YXCVu9|=Qf3yI1%`JZ{q|-i&07!PT z9BXfzk>P6pq3>Hy&0vY3yq}d=M+NUxQJKriTqfN7q*B2KMK(VHophglW_D|G7JZd4 z_B7<`R=v80+{A2yp(C+%<8-9F`%0DM2YCZR>_CpPF>_xAk)ZXVS_+cYU}*XWDAEa& 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�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 diff --git a/base/cvd/cuttlefish/host/commands/cvd/cli/parser/doc/vm.svg b/base/cvd/cuttlefish/host/commands/cvd/cli/parser/doc/vm.svg index 7a54f7d5f58..0dcbd63a445 100644 --- a/base/cvd/cuttlefish/host/commands/cvd/cli/parser/doc/vm.svg +++ b/base/cvd/cuttlefish/host/commands/cvd/cli/parser/doc/vm.svg @@ -1,474 +1,486 @@ - - - - - + + + +%3 + vm - -vm + +vm cpus - -cpus + +cpus vm--cpus - + vm_manager - -vm_manager + +vm_manager vm--vm_manager - + - + vm--vm_manager - + vsock_guest_cid - -vsock_guest_cid + +vsock_guest_cid vm--vsock_guest_cid - + enable_minimal_mode - -enable_minimal_mode + +enable_minimal_mode vm--enable_minimal_mode - + restart_subprocesses - -restart_subprocesses + +restart_subprocesses vm--restart_subprocesses - + setupwizard_mode - -setupwizard_mode + +setupwizard_mode vm--setupwizard_mode - + smt - -smt + +smt vm--smt - + use_allocd - -use_allocd + +use_allocd vm--use_allocd - + use_sdcard - -use_sdcard + +use_sdcard vm--use_sdcard - + uuid - -uuid + +uuid vm--uuid - + file_verbosity - -file_verbosity + +file_verbosity vm--file_verbosity - + verbosity - -verbosity + +verbosity vm--verbosity - + Run_file_discovery - -Run_file_discovery + +Run_file_discovery vm--Run_file_discovery - + config - -config + +config vm--config - + memory_mb - -memory_mb + +memory_mb vm--memory_mb - + custom_actions - -custom_actions + +custom_actions vm--custom_actions - + + + + +enable_pkvm + +enable_pkvm + + + +vm--enable_pkvm + - + security - -security + +security - + vm--security - + - + kernel - -kernel + +kernel - + vm--kernel - + - + crosvm - -crosvm + +crosvm - + vm_manager--crosvm - + - + qemu - -qemu + +qemu - + vm_manager--qemu - + - + gem5 - -gem5 + +gem5 - + vm_manager--gem5 - + - + crosvm_binary_dir - -binary_dir + +binary_dir - + qemu_binary_dir - -binary_dir + +binary_dir - + gem5_binary_dir - -binary_dir + +binary_dir - + crosvm--crosvm_binary_dir - + - + seccomp_policy_dir - -seccomp_policy_dir + +seccomp_policy_dir - + crosvm--seccomp_policy_dir - + - + enable_sandbox - -enable_sandbox + +enable_sandbox - + crosvm--enable_sandbox - + - + simple_media_device - -simple_media_device + +simple_media_device - + crosvm--simple_media_device - + - + v4l2_proxy - -v4l2_proxy + +v4l2_proxy - + crosvm--v4l2_proxy - + - + qemu--qemu_binary_dir - + - + gem5--gem5_binary_dir - + - + checkpoint_dir - -checkpoint_dir + +checkpoint_dir - + gem5--checkpoint_dir - + - + debug_file - -debug_file + +debug_file - + gem5--debug_file - + - + debug_flags - -debug_flags + +debug_flags - + gem5--debug_flags - + - + guest_enforce_security - -guest_enforce_security + +guest_enforce_security - + security--guest_enforce_security - + - + serial_number - -serial_number + +serial_number - + security--serial_number - + - + secure_hals - -secure_hals + +secure_hals - + security--secure_hals - + - + enable_kernel_log - -enable_kernel_log + +enable_kernel_log - + kernel--enable_kernel_log - + - + kgdb - -kgdb + +kgdb - + kernel--kgdb - + - + gdb_port - -gdb_port + +gdb_port - + kernel--gdb_port - + - + console - -console + +console - + kernel--console - + - + extra_kernel_cmdline - -extra_kernel_cmdline + +extra_kernel_cmdline - + kernel--extra_kernel_cmdline - + - + initramfs_path - -initramfs_path + +initramfs_path - + kernel--initramfs_path - + - + path - -path + +path - + kernel--path - + diff --git a/base/cvd/cuttlefish/host/commands/cvd/cli/parser/golang/load_config.pb.go b/base/cvd/cuttlefish/host/commands/cvd/cli/parser/golang/load_config.pb.go index 8006029776b..80041941764 100644 --- a/base/cvd/cuttlefish/host/commands/cvd/cli/parser/golang/load_config.pb.go +++ b/base/cvd/cuttlefish/host/commands/cvd/cli/parser/golang/load_config.pb.go @@ -141,15 +141,16 @@ func (ModemSimulatorSimType) EnumDescriptor() ([]byte, []int) { } type EnvironmentSpecification struct { - state protoimpl.MessageState `protogen:"open.v1"` - Instances []*Instance `protobuf:"bytes,1,rep,name=instances,proto3" json:"instances,omitempty"` - Fetch *Fetch `protobuf:"bytes,2,opt,name=fetch,proto3,oneof" json:"fetch,omitempty"` - Metrics *Metrics `protobuf:"bytes,3,opt,name=metrics,proto3,oneof" json:"metrics,omitempty"` - Common *Common `protobuf:"bytes,4,opt,name=common,proto3,oneof" json:"common,omitempty"` - NetsimBt *bool `protobuf:"varint,5,opt,name=netsim_bt,json=netsimBt,proto3,oneof" json:"netsim_bt,omitempty"` - NetsimUwb *bool `protobuf:"varint,6,opt,name=netsim_uwb,json=netsimUwb,proto3,oneof" json:"netsim_uwb,omitempty"` - NetsimArgs []string `protobuf:"bytes,7,rep,name=netsim_args,json=netsimArgs,proto3" json:"netsim_args,omitempty"` - NetsimModem *bool `protobuf:"varint,8,opt,name=netsim_modem,json=netsimModem,proto3,oneof" json:"netsim_modem,omitempty"` + state protoimpl.MessageState `protogen:"open.v1"` + Instances []*Instance `protobuf:"bytes,1,rep,name=instances,proto3" json:"instances,omitempty"` + Fetch *Fetch `protobuf:"bytes,2,opt,name=fetch,proto3,oneof" json:"fetch,omitempty"` + // deprecated v1 metrics enabling field, is not read/used + Metrics *Metrics `protobuf:"bytes,3,opt,name=metrics,proto3,oneof" json:"metrics,omitempty"` + Common *Common `protobuf:"bytes,4,opt,name=common,proto3,oneof" json:"common,omitempty"` + NetsimBt *bool `protobuf:"varint,5,opt,name=netsim_bt,json=netsimBt,proto3,oneof" json:"netsim_bt,omitempty"` + NetsimUwb *bool `protobuf:"varint,6,opt,name=netsim_uwb,json=netsimUwb,proto3,oneof" json:"netsim_uwb,omitempty"` + NetsimArgs []string `protobuf:"bytes,7,rep,name=netsim_args,json=netsimArgs,proto3" json:"netsim_args,omitempty"` + NetsimModem *bool `protobuf:"varint,8,opt,name=netsim_modem,json=netsimModem,proto3,oneof" json:"netsim_modem,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } @@ -243,14 +244,15 @@ func (x *EnvironmentSpecification) GetNetsimModem() bool { // TODO: chadreynolds - when we can make breaking changes and update, use this // in EnvironmentSpecification instead of individual fields type EnvironmentOptions struct { - state protoimpl.MessageState `protogen:"open.v1"` - Fetch *Fetch `protobuf:"bytes,1,opt,name=fetch,proto3,oneof" json:"fetch,omitempty"` - Metrics *Metrics `protobuf:"bytes,2,opt,name=metrics,proto3,oneof" json:"metrics,omitempty"` - Common *Common `protobuf:"bytes,3,opt,name=common,proto3,oneof" json:"common,omitempty"` - NetsimBt *bool `protobuf:"varint,4,opt,name=netsim_bt,json=netsimBt,proto3,oneof" json:"netsim_bt,omitempty"` - NetsimUwb *bool `protobuf:"varint,5,opt,name=netsim_uwb,json=netsimUwb,proto3,oneof" json:"netsim_uwb,omitempty"` - NetsimArgs []string `protobuf:"bytes,6,rep,name=netsim_args,json=netsimArgs,proto3" json:"netsim_args,omitempty"` - NetsimModem *bool `protobuf:"varint,7,opt,name=netsim_modem,json=netsimModem,proto3,oneof" json:"netsim_modem,omitempty"` + state protoimpl.MessageState `protogen:"open.v1"` + Fetch *Fetch `protobuf:"bytes,1,opt,name=fetch,proto3,oneof" json:"fetch,omitempty"` + // deprecated v1 metrics enabling field, is not read/used + Metrics *Metrics `protobuf:"bytes,2,opt,name=metrics,proto3,oneof" json:"metrics,omitempty"` + Common *Common `protobuf:"bytes,3,opt,name=common,proto3,oneof" json:"common,omitempty"` + NetsimBt *bool `protobuf:"varint,4,opt,name=netsim_bt,json=netsimBt,proto3,oneof" json:"netsim_bt,omitempty"` + NetsimUwb *bool `protobuf:"varint,5,opt,name=netsim_uwb,json=netsimUwb,proto3,oneof" json:"netsim_uwb,omitempty"` + NetsimArgs []string `protobuf:"bytes,6,rep,name=netsim_args,json=netsimArgs,proto3" json:"netsim_args,omitempty"` + NetsimModem *bool `protobuf:"varint,7,opt,name=netsim_modem,json=netsimModem,proto3,oneof" json:"netsim_modem,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } @@ -1462,6 +1464,7 @@ type Vm struct { CustomActions []*CustomAction `protobuf:"bytes,9,rep,name=custom_actions,json=customActions,proto3" json:"custom_actions,omitempty"` // Desired user space page size. PageSize *UserPageSize `protobuf:"varint,10,opt,name=page_size,json=pageSize,proto3,enum=cuttlefish.cvd.config.UserPageSize,oneof" json:"page_size,omitempty"` + EnablePkvm *bool `protobuf:"varint,11,opt,name=enable_pkvm,json=enablePkvm,proto3,oneof" json:"enable_pkvm,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } @@ -1579,6 +1582,13 @@ func (x *Vm) GetPageSize() UserPageSize { return UserPageSize_USER_PAGE_SIZE_UNSPECIFIED } +func (x *Vm) GetEnablePkvm() bool { + if x != nil && x.EnablePkvm != nil { + return *x.EnablePkvm + } + return false +} + type isVm_Vmm interface { isVm_Vmm() } @@ -2198,7 +2208,7 @@ const file_cuttlefish_host_commands_cvd_cli_parser_load_config_proto_rawDesc = " "\tV4l2Proxy\x12$\n" + "\vdevice_path\x18\x01 \x01(\tH\x00R\n" + "devicePath\x88\x01\x01B\x0e\n" + - "\f_device_path\"\xb7\x04\n" + + "\f_device_path\"\xed\x04\n" + "\x02Vm\x12\x17\n" + "\x04cpus\x18\x01 \x01(\rH\x01R\x04cpus\x88\x01\x01\x12 \n" + "\tmemory_mb\x18\x02 \x01(\rH\x02R\bmemoryMb\x88\x01\x01\x12\"\n" + @@ -2211,7 +2221,9 @@ const file_cuttlefish_host_commands_cvd_cli_parser_load_config_proto_rawDesc = " "\x04qemu\x18\b \x01(\v2\x1b.cuttlefish.cvd.config.QemuH\x00R\x04qemu\x12J\n" + "\x0ecustom_actions\x18\t \x03(\v2#.cuttlefish.cvd.config.CustomActionR\rcustomActions\x12E\n" + "\tpage_size\x18\n" + - " \x01(\x0e2#.cuttlefish.cvd.config.UserPageSizeH\x06R\bpageSize\x88\x01\x01B\x05\n" + + " \x01(\x0e2#.cuttlefish.cvd.config.UserPageSizeH\x06R\bpageSize\x88\x01\x01\x12$\n" + + "\venable_pkvm\x18\v \x01(\bH\aR\n" + + "enablePkvm\x88\x01\x01B\x05\n" + "\x03vmmB\a\n" + "\x05_cpusB\f\n" + "\n" + @@ -2220,7 +2232,8 @@ const file_cuttlefish_host_commands_cvd_cli_parser_load_config_proto_rawDesc = " "\x11_setupwizard_modeB\a\n" + "\x05_uuidB\f\n" + "\n" + - "_page_size\"\x8b\x02\n" + + "_page_sizeB\x0e\n" + + "\f_enable_pkvm\"\x8b\x02\n" + "\x06Crosvm\x12*\n" + "\x0eenable_sandbox\x18\x01 \x01(\bH\x00R\renableSandbox\x88\x01\x01\x123\n" + "\x13simple_media_device\x18\x02 \x01(\bH\x01R\x11simpleMediaDevice\x88\x01\x01\x12\"\n" + diff --git a/base/cvd/cuttlefish/host/commands/cvd/cli/parser/instance/cf_vm_configs.cpp b/base/cvd/cuttlefish/host/commands/cvd/cli/parser/instance/cf_vm_configs.cpp index d161f3d3ed2..fbd3cee10bf 100644 --- a/base/cvd/cuttlefish/host/commands/cvd/cli/parser/instance/cf_vm_configs.cpp +++ b/base/cvd/cuttlefish/host/commands/cvd/cli/parser/instance/cf_vm_configs.cpp @@ -50,6 +50,7 @@ inline constexpr char kFlagCrosvmSimpleMediaDevice[] = "crosvm_simple_media_device"; inline constexpr char kFlagCrosvmV4l2Proxy[] = "crosvm_v4l2_proxy"; inline constexpr char kFlagVhostUserVsock[] = "vhost_user_vsock"; +inline constexpr char kFlagEnablePkvm[] = "enable_pkvm"; std::set GatherFlagNamesUsedInInstanceConfig(const Instance& ins) { std::set names; @@ -87,6 +88,9 @@ std::set GatherFlagNamesUsedInInstanceConfig(const Instance& ins) { ins.vm().crosvm().has_vhost_user_vsock()) { names.insert(kFlagVhostUserVsock); } + if (ins.vm().has_enable_pkvm()) { + names.insert(kFlagEnablePkvm); + } return names; } @@ -187,6 +191,11 @@ static std::string VhostUserVsock(const Instance& instance) { : default_val; } +static bool EnablePkvm(const Instance& instance) { + const auto& vm = instance.vm(); + return vm.has_enable_pkvm() ? vm.enable_pkvm() : CF_DEFAULTS_ENABLE_PKVM; +} + static std::vector UserPageSize( const EnvironmentSpecification& cfg) { std::vector ret; @@ -276,6 +285,9 @@ Result> GenerateVmFlags( flags.emplace_back( GenerateInstanceFlag(kFlagVhostUserVsock, cfg, VhostUserVsock)); } + if (used_names.contains(kFlagEnablePkvm)) { + flags.emplace_back(GenerateInstanceFlag(kFlagEnablePkvm, cfg, EnablePkvm)); + } flags = MergeResults(std::move(flags), CF_EXPECT(CustomConfigsFlags(cfg))); flags = MergeResults(std::move(flags), UserPageSize(cfg)); diff --git a/base/cvd/cuttlefish/host/commands/cvd/cli/parser/load_config.proto b/base/cvd/cuttlefish/host/commands/cvd/cli/parser/load_config.proto index 71a56da20e4..10a9308b3de 100644 --- a/base/cvd/cuttlefish/host/commands/cvd/cli/parser/load_config.proto +++ b/base/cvd/cuttlefish/host/commands/cvd/cli/parser/load_config.proto @@ -193,6 +193,7 @@ message Vm { repeated CustomAction custom_actions = 9; // Desired user space page size. optional UserPageSize page_size = 10; + optional bool enable_pkvm = 11; } message Crosvm { diff --git a/base/cvd/cuttlefish/host/commands/start/main.cc b/base/cvd/cuttlefish/host/commands/start/main.cc index 3b92236e948..67f1eea7fee 100644 --- a/base/cvd/cuttlefish/host/commands/start/main.cc +++ b/base/cvd/cuttlefish/host/commands/start/main.cc @@ -155,6 +155,7 @@ const std::unordered_set& BoolFlags() { "enable_kernel_log", "enable_minimal_mode", "enable_modem_simulator", + "enable_pkvm", "enable_sandbox", "enable_usb", "enable_virtiofs", diff --git a/base/cvd/cuttlefish/host/libs/config/cuttlefish_config.h b/base/cvd/cuttlefish/host/libs/config/cuttlefish_config.h index 388d77fa0e1..fd5f4f91c99 100644 --- a/base/cvd/cuttlefish/host/libs/config/cuttlefish_config.h +++ b/base/cvd/cuttlefish/host/libs/config/cuttlefish_config.h @@ -404,6 +404,7 @@ class CuttlefishConfig { bool crosvm_simple_media_device() const; std::string crosvm_v4l2_proxy() const; bool use_pmem() const; + bool enable_pkvm() const; // Wifi MAC address inside the guest int wifi_mac_prefix() const; @@ -656,6 +657,7 @@ class CuttlefishConfig { void set_crosvm_simple_media_device(const bool simple_media_device); void set_crosvm_v4l2_proxy(const std::string v4l2_proxy); void set_use_pmem(const bool use_pmem); + void set_enable_pkvm(bool enable_pkvm); // Wifi MAC address inside the guest void set_wifi_mac_prefix(const int wifi_mac_prefix); // Gnss grpc proxy server port inside the host diff --git a/base/cvd/cuttlefish/host/libs/config/cuttlefish_config_instance.cpp b/base/cvd/cuttlefish/host/libs/config/cuttlefish_config_instance.cpp index 68afec0d250..bafd2577e9b 100644 --- a/base/cvd/cuttlefish/host/libs/config/cuttlefish_config_instance.cpp +++ b/base/cvd/cuttlefish/host/libs/config/cuttlefish_config_instance.cpp @@ -1871,6 +1871,15 @@ bool CuttlefishConfig::InstanceSpecific::use_pmem() const { return (*Dictionary())[kCrosvmUsePmem].asBool(); } +static constexpr char kEnablePkvm[] = "enable_pkvm"; +void CuttlefishConfig::MutableInstanceSpecific::set_enable_pkvm( + bool enable_pkvm) { + (*Dictionary())[kEnablePkvm] = enable_pkvm; +} +bool CuttlefishConfig::InstanceSpecific::enable_pkvm() const { + return (*Dictionary())[kEnablePkvm].asBool(); +} + static constexpr char kEnableTapDevices[] = "enable_tap_devices"; void CuttlefishConfig::MutableInstanceSpecific::set_enable_tap_devices( const bool enable_tap_devices) { diff --git a/base/cvd/cuttlefish/host/libs/config/kernel_args.cpp b/base/cvd/cuttlefish/host/libs/config/kernel_args.cpp index 26561270951..342a4e1437a 100644 --- a/base/cvd/cuttlefish/host/libs/config/kernel_args.cpp +++ b/base/cvd/cuttlefish/host/libs/config/kernel_args.cpp @@ -109,6 +109,11 @@ std::vector KernelCommandLineFromConfig( const CuttlefishConfig::InstanceSpecific& instance) { std::vector kernel_cmdline; AppendVector(&kernel_cmdline, VmManagerKernelCmdline(config, instance)); + if (instance.enable_pkvm() && instance.target_arch() == Arch::Arm64) { + kernel_cmdline.push_back("kvm-arm.mode=protected"); + // Makes the guest kernel's early loader modprobe the pKVM IOMMU driver. + kernel_cmdline.push_back("kvm-arm.protected_modules=pkvm_iommu_temp"); + } AppendVector(&kernel_cmdline, config.extra_kernel_cmdline()); return kernel_cmdline; } diff --git a/base/cvd/cuttlefish/host/libs/vm_manager/crosvm_manager.cpp b/base/cvd/cuttlefish/host/libs/vm_manager/crosvm_manager.cpp index 71957bc0cec..c18f93b453d 100644 --- a/base/cvd/cuttlefish/host/libs/vm_manager/crosvm_manager.cpp +++ b/base/cvd/cuttlefish/host/libs/vm_manager/crosvm_manager.cpp @@ -574,6 +574,12 @@ Result> CrosvmManager::StartCommands( crosvm_cmd.AddKvmPath(config.kvm_path()); } + // A pkvm guest needs to boot at virtual EL2; crosvm verifies host support + // (KVM_CAP_ARM_EL2, GICv3 irqchip) and fails to start otherwise. + if (instance.enable_pkvm()) { + crosvm_cmd.Cmd().AddParameter("--nested=on"); + } + if (!instance.smt()) { crosvm_cmd.Cmd().AddParameter("--no-smt"); } @@ -629,7 +635,14 @@ Result> CrosvmManager::StartCommands( } if (instance.hwcomposer() != kHwComposerNone) { - const bool pmem_disabled = instance.mte() || !instance.use_pmem(); + // pmem is disabled for pkvm guests: the pmem backing files are mmap'd + // MAP_SHARED, and host writeback of storage-backed pages triggers + // mmu-notifiers that arm64 KVM currently handles by tearing down the + // guest's entire shadow stage-2 instead of a range-scoped invalidation + // (see the nested_mmu reverse-mapping TODO in arch/arm64/kvm/mmu.c), + // which makes the guest extremely slow. + const bool pmem_disabled = + instance.mte() || instance.enable_pkvm() || !instance.use_pmem(); const std::string pmem_path = HwcomposerPmemPath(instance); if (!pmem_disabled && FileExists(pmem_path)) { crosvm_cmd.Cmd().AddParameter("--pmem=path=", pmem_path); @@ -716,7 +729,8 @@ Result> CrosvmManager::StartCommands( } #endif - const bool pmem_disabled = instance.mte() || !instance.use_pmem(); + const bool pmem_disabled = + instance.mte() || instance.enable_pkvm() || !instance.use_pmem(); const std::string access_kregistry = AccessKregistryPath(instance); if (!pmem_disabled && FileExists(access_kregistry)) { crosvm_cmd.Cmd().AddParameter("--pmem=path=", access_kregistry); From 28447ed4596aeb2a0cb8315ba6ce7079b87a62f7 Mon Sep 17 00:00:00 2001 From: JaeMan Park Date: Tue, 21 Jul 2026 15:43:40 +0900 Subject: [PATCH 44/53] Fix file already exist error while running substitute in Docker In the OverlayFS, even if unlink() is succeeded, looks like there is a delay between unlink call and the file is actually disappears. Change to use rename call which ensures atomic operation for substitution. --- .../host/commands/cvd/fetch/substitute.cc | 26 ++++++++++++++++--- 1 file changed, 23 insertions(+), 3 deletions(-) diff --git a/base/cvd/cuttlefish/host/commands/cvd/fetch/substitute.cc b/base/cvd/cuttlefish/host/commands/cvd/fetch/substitute.cc index 8ccb474b900..e2f80a1cddd 100644 --- a/base/cvd/cuttlefish/host/commands/cvd/fetch/substitute.cc +++ b/base/cvd/cuttlefish/host/commands/cvd/fetch/substitute.cc @@ -17,8 +17,10 @@ #include +#include #include #include +#include #include #include #include @@ -29,6 +31,7 @@ #include #include "absl/log/log.h" #include "absl/strings/match.h" +#include "fmt/format.h" #include "cuttlefish/common/libs/utils/environment.h" #include "cuttlefish/common/libs/utils/files.h" @@ -64,10 +67,27 @@ Result Substitute(const std::string& target, CF_EXPECT(EnsureDirectoryExists(android::base::Dirname(full_link_name))); - int unlink_res = unlink(full_link_name.c_str()); - CF_EXPECTF(unlink_res == 0 || errno == ENOENT, "{}", StrError(errno)); + std::random_device rd; + std::string tmp_link_name; + constexpr int kMaxRetries = 10; + for (int attempt = 0; attempt < kMaxRetries; ++attempt) { + tmp_link_name = fmt::format("{}.tmp_{}_{}", full_link_name, getpid(), rd()); + auto symlink_res = Symlink(target, tmp_link_name); + if (symlink_res.has_value()) { + break; + } + if (errno == EEXIST && attempt + 1 < kMaxRetries) { + continue; + } + return symlink_res; + } + + if (rename(tmp_link_name.c_str(), full_link_name.c_str()) != 0) { + const int err = errno; + unlink(tmp_link_name.c_str()); + return CF_ERRF("Failed to rename symlink: {}", StrError(err)); + } - CF_EXPECT(Symlink(target, full_link_name)); return {}; } From d6fe6c2515981649ebcbbf1b3230094d8ee1f39c Mon Sep 17 00:00:00 2001 From: Ram Muthiah Date: Sat, 22 Aug 2026 22:41:54 +0100 Subject: [PATCH 45/53] ci: Remove pseudo-TTY allocation (-it) from podman exec in e2e test runners When `podman exec -it` was executed in CI scripts, pseudo-terminal allocation (-t) caused stdout lines to be emitted with CRLF (\r\n). In `runner-special`, capturing this into bash passed carriage returns to `bazel test`, which failed with: invalid target name '... \r': target names may not end with carriage returns This failure appeared intermittently / "flaky" across CI runs because: - The previous query used `sh -c "stty -onlcr && bazel query ..." 2>/dev/null`. - On runner instances where `stty -onlcr` returned non-zero (non-TTY subshell), the `&&` short-circuited and silently skipped `bazel query`. With `targets=""`, the loop ran 0 tests and falsely passed. - On runner instances where `stty` succeeded, `bazel query` executed, but the host-side PTY bridge still appended `\r\n`, causing Bazel to reject the target names on every retry. Remove `-it` from all `podman exec` calls in both `presubmit.yaml` and `run-cw-sharded-e2e-test/action.yaml`. TAG=agy CONV=cee1b9c6-d222-4154-8c11-924d01e88f39 --- .github/actions/run-cw-sharded-e2e-test/action.yaml | 4 ++-- .github/workflows/presubmit.yaml | 12 ++++++------ 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/.github/actions/run-cw-sharded-e2e-test/action.yaml b/.github/actions/run-cw-sharded-e2e-test/action.yaml index 4687e55504f..7f2a50979e4 100644 --- a/.github/actions/run-cw-sharded-e2e-test/action.yaml +++ b/.github/actions/run-cw-sharded-e2e-test/action.yaml @@ -42,7 +42,7 @@ runs: sudo podman run --name tester -d --privileged --pids-limit=8192 -v /tmp/cw_bazel:/tmp/cw_bazel -v .:/src/workspace -w /src/workspace/e2etests android-cuttlefish-e2etest:latest # Compute tests for this runner - all_tests=$( sudo podman exec --user=testrunner -it tester bazel --output_user_root=/tmp/cw_bazel/output query --noshow_progress 'kind("go_test", orchestration/...) except attr(flaky, 1, //...) except attr(tags, "[\[ ]host-ready-special[,\]]", //...)' | grep -e "^\/\/" | sort ) + all_tests=$( sudo podman exec --user=testrunner tester bazel --output_user_root=/tmp/cw_bazel/output query --noshow_progress 'kind("go_test", orchestration/...) except attr(flaky, 1, //...) except attr(tags, "[\[ ]host-ready-special[,\]]", //...)' | grep -e "^\/\/" | sort ) all_tests_count=$(echo "${all_tests}" | wc --lines) echo "ALL TESTS: ${all_tests_count}" echo "${all_tests}" @@ -74,7 +74,7 @@ runs: echo "running test: ${t}" sudo podman rm -f tester sudo podman run --name tester -d --privileged --pids-limit=8192 -v /tmp/cw_bazel:/tmp/cw_bazel -v .:/src/workspace -w /src/workspace/e2etests android-cuttlefish-e2etest:latest - sudo podman exec --user=testrunner -it tester bazel --output_user_root=/tmp/cw_bazel/output test --sandbox_writable_path=/home/testrunner $t + sudo podman exec --user=testrunner tester bazel --output_user_root=/tmp/cw_bazel/output test --sandbox_writable_path=/home/testrunner $t done - name: Upload test logs if: always() diff --git a/.github/workflows/presubmit.yaml b/.github/workflows/presubmit.yaml index 70b043abc5b..1bbd7cd156d 100644 --- a/.github/workflows/presubmit.yaml +++ b/.github/workflows/presubmit.yaml @@ -373,7 +373,7 @@ jobs: # Flaky tests would be executed in clean container everytime, rather than using `cvd reset` # in a tainted container. sudo podman run --name tester -d --privileged --pids-limit=8192 -v /tmp/cw_bazel:/tmp/cw_bazel -v .:/src/workspace -w /src/workspace/e2etests android-cuttlefish-e2etest:latest - targets=$(sudo podman exec --user=testrunner -it tester sh -c "stty -onlcr && bazel --output_user_root=/tmp/cw_bazel/output query --noshow_progress 'attr(flaky, 1, orchestration/...)' 2>/dev/null" | sort) + targets=$(sudo podman exec --user=testrunner tester bazel --output_user_root=/tmp/cw_bazel/output query --noshow_progress 'attr(flaky, 1, orchestration/...)' | sort) echo "FLAKY TARGETS:" echo "${targets}" echo "" @@ -385,7 +385,7 @@ jobs: echo "Attempt: ${attempt} of ${ATTEMPTS}" sudo podman rm -f tester sudo podman run --name tester -d --privileged --pids-limit=8192 -v /tmp/cw_bazel:/tmp/cw_bazel -v .:/src/workspace -w /src/workspace/e2etests android-cuttlefish-e2etest:latest - sudo podman exec --user=testrunner -it tester bazel --output_user_root=/tmp/cw_bazel/output test --test_timeout 600 --sandbox_writable_path=/home/testrunner --flaky_test_attempts=1 ${t} && break || true + sudo podman exec --user=testrunner tester bazel --output_user_root=/tmp/cw_bazel/output test --test_timeout 600 --sandbox_writable_path=/home/testrunner --flaky_test_attempts=1 ${t} && break || true attempt=$((attempt+1)) done if [[ ${attempt} -gt ${ATTEMPTS} ]]; then @@ -397,14 +397,14 @@ jobs: # Run verify_access_token_test sudo podman run --name tester -d --privileged --pids-limit=8192 -v /tmp/cw_bazel:/tmp/cw_bazel -v .:/src/workspace -w /src/workspace/e2etests android-cuttlefish-e2etest:latest sleep 30s # Add delay before restarting cuttlefish-host_orchestrator service. - sudo podman exec -it tester sh -c 'echo "orchestrator_android_build_url=http://localhost:8090" >> /etc/default/cuttlefish-host_orchestrator && service cuttlefish-host_orchestrator restart' - sudo podman exec --user=testrunner -it tester bazel --output_user_root=/tmp/cw_bazel/output test //orchestration/verify_access_token_test:verify_access_token_test_test + sudo podman exec tester sh -c 'echo "orchestrator_android_build_url=http://localhost:8090" >> /etc/default/cuttlefish-host_orchestrator && service cuttlefish-host_orchestrator restart' + sudo podman exec --user=testrunner tester bazel --output_user_root=/tmp/cw_bazel/output test //orchestration/verify_access_token_test:verify_access_token_test_test sudo podman rm -f tester # Run create_with_gce_metadata_credentials_test sudo podman run --name tester -d --privileged --pids-limit=8192 -v /tmp/cw_bazel:/tmp/cw_bazel -v .:/src/workspace -w /src/workspace/e2etests android-cuttlefish-e2etest:latest sleep 30s # Add delay before restarting cuttlefish-host_orchestrator service. - sudo podman exec -it tester sh -c 'echo "build_api_credentials_use_gce_metadata=true" >> /etc/default/cuttlefish-host_orchestrator && service cuttlefish-host_orchestrator restart' - sudo podman exec --user=testrunner -it tester bazel --output_user_root=/tmp/cw_bazel/output test //orchestration/create_with_gce_metadata_credentials_test:create_with_gce_metadata_credentials_test_test + sudo podman exec tester sh -c 'echo "build_api_credentials_use_gce_metadata=true" >> /etc/default/cuttlefish-host_orchestrator && service cuttlefish-host_orchestrator restart' + sudo podman exec --user=testrunner tester bazel --output_user_root=/tmp/cw_bazel/output test //orchestration/create_with_gce_metadata_credentials_test:create_with_gce_metadata_credentials_test_test sudo podman rm -f tester - name: Upload test logs if: always() From 2d0be3731de8fea2694c95e8f6c65026eb57203b Mon Sep 17 00:00:00 2001 From: Ram Muthiah Date: Sat, 22 Aug 2026 22:42:12 +0100 Subject: [PATCH 46/53] ci: Remove trailing character slice workaround in run-cw-sharded-e2e-test Now that `-it` has been removed and `podman exec` produces clean Unix stdout lines without trailing carriage returns, remove the `t="${t::-1}"` string slicing workaround. TAG=agy CONV=cee1b9c6-d222-4154-8c11-924d01e88f39 --- .github/actions/run-cw-sharded-e2e-test/action.yaml | 1 - 1 file changed, 1 deletion(-) diff --git a/.github/actions/run-cw-sharded-e2e-test/action.yaml b/.github/actions/run-cw-sharded-e2e-test/action.yaml index 7f2a50979e4..15624352dc4 100644 --- a/.github/actions/run-cw-sharded-e2e-test/action.yaml +++ b/.github/actions/run-cw-sharded-e2e-test/action.yaml @@ -70,7 +70,6 @@ runs: # Run tests targets=( $(echo ${runner_tests}) ) for t in "${targets[@]}"; do - t="${t::-1}" echo "running test: ${t}" sudo podman rm -f tester sudo podman run --name tester -d --privileged --pids-limit=8192 -v /tmp/cw_bazel:/tmp/cw_bazel -v .:/src/workspace -w /src/workspace/e2etests android-cuttlefish-e2etest:latest From a550791eef12094c8bb2f9461d952fa5b8f07ff2 Mon Sep 17 00:00:00 2001 From: Ram Muthiah Date: Wed, 26 Aug 2026 10:58:13 +0100 Subject: [PATCH 47/53] Use a special cache version for version-1.56-dev This has diverged enough from main that we are seeing some strangeness. --- .config/cache-config.env | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.config/cache-config.env b/.config/cache-config.env index 774a4628b40..cbd68655cd1 100644 --- a/.config/cache-config.env +++ b/.config/cache-config.env @@ -1,3 +1,3 @@ -CACHE_VERSION=v1 +CACHE_VERSION=v1_56_dev BAZEL_REMOTE_CACHE="https://storage.googleapis.com/android-cuttlefish-cache" From 6cdd9457408e92c0b6fdf540e17604073ed50c52 Mon Sep 17 00:00:00 2001 From: Sergio Andres Rodriguez Orama Date: Thu, 30 Jul 2026 13:05:49 -0400 Subject: [PATCH 48/53] Use fixed crun version in relevant GitHub Actions GitHub Actions runners have been failing with non-deterministic failures during e2e tests with the error "crun: unknown version specified". This can occur because newer versions of Podman on the `ubuntu-24.04` runner generate OCI configurations that are incompatible with the older version of `crun` pre-installed on the runner. BUG=b/540850996 Assisted-by: Jetski:Gemini 3.5 Flash --- .../run-cw-sharded-e2e-test/action.yaml | 2 ++ .github/actions/upgrade-crun/action.yaml | 29 +++++++++++++++++++ .github/workflows/presubmit.yaml | 6 ++++ 3 files changed, 37 insertions(+) create mode 100644 .github/actions/upgrade-crun/action.yaml diff --git a/.github/actions/run-cw-sharded-e2e-test/action.yaml b/.github/actions/run-cw-sharded-e2e-test/action.yaml index 15624352dc4..dbfd2252437 100644 --- a/.github/actions/run-cw-sharded-e2e-test/action.yaml +++ b/.github/actions/run-cw-sharded-e2e-test/action.yaml @@ -16,6 +16,8 @@ runs: with: name: android-cuttlefish-e2etest-image-tar github-token: ${{ github.token }} + - name: Upgrade crun + uses: ./.github/actions/upgrade-crun - name: Run tests shell: bash env: diff --git a/.github/actions/upgrade-crun/action.yaml b/.github/actions/upgrade-crun/action.yaml new file mode 100644 index 00000000000..53dc2120d50 --- /dev/null +++ b/.github/actions/upgrade-crun/action.yaml @@ -0,0 +1,29 @@ +name: 'Upgrade crun' +description: 'Upgrade crun to latest version to avoid OCI compatibility issues' +runs: + using: "composite" + steps: + - name: Upgrade crun + shell: bash + run: | + TARGET_VERSION="1.28" + EXPECTED_HASH="2aa6b7024a9c9f153895c0d11ae233d3758f54844011c3a039e3e89048d01d42" + CRUN_PATH=$(which crun || echo "/usr/bin/crun") + echo "Current crun path: $CRUN_PATH" + if [ -f "$CRUN_PATH" ]; then + echo "Current crun version:" + $CRUN_PATH --version + fi + + TEMP_CRUN=$(mktemp) + echo "Downloading crun $TARGET_VERSION..." + curl -L -o "$TEMP_CRUN" https://github.com/containers/crun/releases/download/${TARGET_VERSION}/crun-${TARGET_VERSION}-linux-amd64 + + echo "Verifying hash..." + echo "$EXPECTED_HASH $TEMP_CRUN" | sha256sum --check + + echo "Installing crun..." + sudo mv "$TEMP_CRUN" "$CRUN_PATH" + sudo chmod +x "$CRUN_PATH" + echo "Upgraded crun version:" + $CRUN_PATH --version diff --git a/.github/workflows/presubmit.yaml b/.github/workflows/presubmit.yaml index 1bbd7cd156d..a1fc6b6c533 100644 --- a/.github/workflows/presubmit.yaml +++ b/.github/workflows/presubmit.yaml @@ -304,6 +304,8 @@ jobs: with: name: debs_amd64 github-token: ${{ github.token }} + - name: Upgrade crun + uses: ./.github/actions/upgrade-crun - name: Build image run: | tar -xvf debs_amd64.tar @@ -363,6 +365,8 @@ jobs: with: name: android-cuttlefish-e2etest-image-tar github-token: ${{ github.token }} + - name: Upgrade crun + uses: ./.github/actions/upgrade-crun - name: Run tests run: | sudo podman info @@ -509,6 +513,8 @@ jobs: uses: actions/download-artifact@v7 with: name: cuttlefish-orchestration-amd64 + - name: Upgrade crun + uses: ./.github/actions/upgrade-crun - name: Load docker image as podman image run: | sudo sysctl -w kernel.unprivileged_userns_clone=1 From 2d4badbd7f957384d7551bdfd93ac1c24cfbd28f Mon Sep 17 00:00:00 2001 From: My Name Date: Tue, 30 Jun 2026 14:45:25 +0000 Subject: [PATCH 49/53] Revert Ensure Proper FIFO Provisioning for Shared UWB Services --- .../host/commands/run_cvd/launch/uwb_connector.cpp | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/base/cvd/cuttlefish/host/commands/run_cvd/launch/uwb_connector.cpp b/base/cvd/cuttlefish/host/commands/run_cvd/launch/uwb_connector.cpp index ed03df4292f..721255ba414 100644 --- a/base/cvd/cuttlefish/host/commands/run_cvd/launch/uwb_connector.cpp +++ b/base/cvd/cuttlefish/host/commands/run_cvd/launch/uwb_connector.cpp @@ -40,7 +40,7 @@ namespace cuttlefish { Result> UwbConnector( const CuttlefishConfig& config, const CuttlefishConfig::InstanceSpecific& instance) { - if (!config.enable_host_uwb()) { + if (!instance.enable_host_uwb_connector()) { return {}; } std::vector fifo_paths = { @@ -51,9 +51,6 @@ Result> UwbConnector( for (const auto& path : fifo_paths) { fifos.push_back(CF_EXPECT(CreateOrReuseAndDrainFifo(path, 0660))); } - if (!instance.enable_host_uwb_connector()) { - return {}; - } return Command(HostBinaryPath("tcp_connector")) .AddParameter("-fifo_out=", fifos[0]) .AddParameter("-fifo_in=", fifos[1]) From 147ecb8bc05a71ba469235143afef79fee118e9c Mon Sep 17 00:00:00 2001 From: Jun Sun Date: Thu, 11 Jun 2026 16:15:01 -0700 Subject: [PATCH 50/53] Fix double-write of bootconfig partition. WriteAll(bootconfig_fd, bootconfig) was being called twice in BootConfigPartition::CreateIfNeeded -- once to capture bytesWritten, once inside the CF_EXPECT() comparison. The second call appended duplicate bytes to the partition file, corrupting it. Drop the second call and compare bytesWritten directly. --- .../assemble_cvd/disk/generate_persistent_bootconfig.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/base/cvd/cuttlefish/host/commands/assemble_cvd/disk/generate_persistent_bootconfig.cpp b/base/cvd/cuttlefish/host/commands/assemble_cvd/disk/generate_persistent_bootconfig.cpp index fe50c8bb3b5..3400681a391 100644 --- a/base/cvd/cuttlefish/host/commands/assemble_cvd/disk/generate_persistent_bootconfig.cpp +++ b/base/cvd/cuttlefish/host/commands/assemble_cvd/disk/generate_persistent_bootconfig.cpp @@ -88,7 +88,7 @@ Result> BootConfigPartition::CreateIfNeeded( VLOG(0) << "bootconfig size is " << bootconfig.size(); ssize_t bytesWritten = WriteAll(bootconfig_fd, bootconfig); - CF_EXPECT(WriteAll(bootconfig_fd, bootconfig) == bootconfig.size(), + CF_EXPECT(bytesWritten == bootconfig.size(), "Failed to write bootconfig to \"" << bootconfig_path << "\""); VLOG(0) << "Bootconfig parameters from vendor boot image and config are " << ReadFile(bootconfig_path); From e1254e3949d8e22763a69f77985af60ce918a057 Mon Sep 17 00:00:00 2001 From: "A. Cody Schuffelen" Date: Fri, 28 Aug 2026 09:11:09 +0100 Subject: [PATCH 51/53] Include secure_env in the debian package, and disable the weaver HAL The Weaver HAL is missing from secure_env_only_oemlock, and it is nontrivial to include because it requires importing the WeaverTa dependency from AOSP. Bug: b/548056221 --- base/cvd/cuttlefish/host/commands/assemble_cvd/flags.cc | 2 +- base/cvd/cuttlefish/package/BUILD.bazel | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/base/cvd/cuttlefish/host/commands/assemble_cvd/flags.cc b/base/cvd/cuttlefish/host/commands/assemble_cvd/flags.cc index b0064fc29b9..965da7da722 100644 --- a/base/cvd/cuttlefish/host/commands/assemble_cvd/flags.cc +++ b/base/cvd/cuttlefish/host/commands/assemble_cvd/flags.cc @@ -410,7 +410,7 @@ Result InitializeCuttlefishConfiguration( "_openwrt"); static constexpr char kDefaultSecure[] = - "oemlock,guest_keymint_insecure,guest_gatekeeper_insecure,weaver"; + "oemlock,guest_keymint_insecure,guest_gatekeeper_insecure"; SetCommandLineOptionWithMode("secure_hals", kDefaultSecure, google::FlagSettingMode::SET_FLAGS_DEFAULT); auto secure_hals = CF_EXPECT(ParseSecureHals(FLAGS_secure_hals)); diff --git a/base/cvd/cuttlefish/package/BUILD.bazel b/base/cvd/cuttlefish/package/BUILD.bazel index 6fd93fe0b0e..2fb8a9eb2c6 100644 --- a/base/cvd/cuttlefish/package/BUILD.bazel +++ b/base/cvd/cuttlefish/package/BUILD.bazel @@ -89,7 +89,7 @@ package_files( "cuttlefish-common/bin/rootcanal": "@rootcanal", "cuttlefish-common/bin/run_cvd": "//cuttlefish/host/commands/run_cvd", "cuttlefish-common/bin/screen_recording_server": "//cuttlefish/host/commands/screen_recording_server", - # "cuttlefish-common/bin/secure_env": "//cuttlefish/host/commands/secure_env", # TODO: schuffelen - make this more complete + "cuttlefish-common/bin/secure_env": "//cuttlefish/host/commands/secure_env", # TODO: schuffelen - make this more complete "cuttlefish-common/bin/sefcontext_compile": "@selinux//:sefcontext_compile", "cuttlefish-common/bin/sensors_simulator": "//cuttlefish/host/commands/sensors_simulator", "cuttlefish-common/bin/simg2img": "@android_system_core//:simg2img", From 89b87018f72d55c71a6bcf8f2599f8815446b8c5 Mon Sep 17 00:00:00 2001 From: "A. Cody Schuffelen" Date: Fri, 28 Aug 2026 09:13:08 +0100 Subject: [PATCH 52/53] Added stub responders for snapshot requests on the missing parts of secure_env Bug: b/548056221 --- .../secure_env/secure_env_only_oemlock.cpp | 18 +++++ .../secure_env/worker_thread_loop_body.cpp | 66 +++++++++++++------ .../secure_env/worker_thread_loop_body.h | 2 + 3 files changed, 66 insertions(+), 20 deletions(-) diff --git a/base/cvd/cuttlefish/host/commands/secure_env/secure_env_only_oemlock.cpp b/base/cvd/cuttlefish/host/commands/secure_env/secure_env_only_oemlock.cpp index 6d61eb97b0a..975539a907c 100644 --- a/base/cvd/cuttlefish/host/commands/secure_env/secure_env_only_oemlock.cpp +++ b/base/cvd/cuttlefish/host/commands/secure_env/secure_env_only_oemlock.cpp @@ -187,6 +187,24 @@ Result SecureEnvMain(int argc, char** argv) { } }); + std::vector stub_snapshot_handlers = { + rust_snapshot_socket2, + keymaster_snapshot_socket2, + gatekeeper_snapshot_socket2, + weaver_snapshot_socket2, + }; + for (SharedFD snapshot_socket : stub_snapshot_handlers) { + threads.emplace_back([snapshot_socket]() { + while (true) { + // infinite loop that returns if resetting responder is needed + auto result = secure_env_impl::WorkerStubLoop(snapshot_socket); + if (!result.ok()) { + LOG(FATAL) << "stub worker failed: " << result.error().Trace(); + } + } + }); + } + auto kernel_events_fd = DupFdFlag(FLAGS_kernel_events_fd); threads.emplace_back(StartKernelEventMonitor(kernel_events_fd, oemlock_lock)); diff --git a/base/cvd/cuttlefish/host/commands/secure_env/worker_thread_loop_body.cpp b/base/cvd/cuttlefish/host/commands/secure_env/worker_thread_loop_body.cpp index 7827cc4b315..25ea922156a 100644 --- a/base/cvd/cuttlefish/host/commands/secure_env/worker_thread_loop_body.cpp +++ b/base/cvd/cuttlefish/host/commands/secure_env/worker_thread_loop_body.cpp @@ -23,6 +23,32 @@ namespace cuttlefish { namespace secure_env_impl { +namespace { + +Result StubHandleSuspendRequest(SharedFD snapshot_socket) { + // Read the suspend request. + SnapshotSocketMessage suspend_request; + CF_EXPECT_EQ( + sizeof(suspend_request), + snapshot_socket->Read(&suspend_request, sizeof(suspend_request)), + "socket read failed: " << snapshot_socket->StrError()); + CF_EXPECT_EQ(SnapshotSocketMessage::kSuspend, suspend_request); + // Send the ACK response. + const SnapshotSocketMessage ack_response = SnapshotSocketMessage::kSuspendAck; + CF_EXPECT_EQ(sizeof(ack_response), + snapshot_socket->Write(&ack_response, sizeof(ack_response)), + "socket write failed: " << snapshot_socket->StrError()); + // Block until resumed. + SnapshotSocketMessage resume_request; + CF_EXPECT_EQ( + sizeof(resume_request), + snapshot_socket->Read(&resume_request, sizeof(resume_request)), + "socket read failed: " << snapshot_socket->StrError()); + CF_EXPECT_EQ(SnapshotSocketMessage::kResume, resume_request); + return {}; +} + +} // namespace Result WorkerInnerLoop(std::function process_callback, SharedFD read_fd, SharedFD snapshot_socket) { @@ -50,26 +76,26 @@ Result WorkerInnerLoop(std::function process_callback, } if (readable_fds.IsSet(snapshot_socket)) { - // Read the suspend request. - SnapshotSocketMessage suspend_request; - CF_EXPECT_EQ( - sizeof(suspend_request), - snapshot_socket->Read(&suspend_request, sizeof(suspend_request)), - "socket read failed: " << snapshot_socket->StrError()); - CF_EXPECT_EQ(SnapshotSocketMessage::kSuspend, suspend_request); - // Send the ACK response. - const SnapshotSocketMessage ack_response = - SnapshotSocketMessage::kSuspendAck; - CF_EXPECT_EQ(sizeof(ack_response), - snapshot_socket->Write(&ack_response, sizeof(ack_response)), - "socket write failed: " << snapshot_socket->StrError()); - // Block until resumed. - SnapshotSocketMessage resume_request; - CF_EXPECT_EQ( - sizeof(resume_request), - snapshot_socket->Read(&resume_request, sizeof(resume_request)), - "socket read failed: " << snapshot_socket->StrError()); - CF_EXPECT_EQ(SnapshotSocketMessage::kResume, resume_request); + CF_EXPECT(StubHandleSuspendRequest(snapshot_socket)); + } + } + + return {}; +} + +Result WorkerStubLoop(SharedFD snapshot_socket) { + for (;;) { + SharedFDSet readable_fds; + readable_fds.Set(snapshot_socket); + + int num_fds = Select(&readable_fds, nullptr, nullptr, nullptr); + if (num_fds < 0) { + LOG(FATAL) << "Select() returned a negative value: " << num_fds + << StrError(errno); + } + + if (readable_fds.IsSet(snapshot_socket)) { + CF_EXPECT(StubHandleSuspendRequest(snapshot_socket)); } } diff --git a/base/cvd/cuttlefish/host/commands/secure_env/worker_thread_loop_body.h b/base/cvd/cuttlefish/host/commands/secure_env/worker_thread_loop_body.h index efe4e167c24..95a9104de89 100644 --- a/base/cvd/cuttlefish/host/commands/secure_env/worker_thread_loop_body.h +++ b/base/cvd/cuttlefish/host/commands/secure_env/worker_thread_loop_body.h @@ -26,5 +26,7 @@ namespace secure_env_impl { Result WorkerInnerLoop(std::function process_callback, SharedFD read_fd, SharedFD snapshot_socket); +Result WorkerStubLoop(SharedFD snapshot_socket); + } // namespace secure_env_impl } // namespace cuttlefish From 53490996a34f73a8911bd5268a08f18bbd3ce93d Mon Sep 17 00:00:00 2001 From: My Name Date: Fri, 28 Aug 2026 09:15:13 +0100 Subject: [PATCH 53/53] improve the LaunchSingleInstance bypass in cvd start --- .../host/commands/cvd/cli/commands/start.cpp | 56 ++++++++++++------- 1 file changed, 37 insertions(+), 19 deletions(-) diff --git a/base/cvd/cuttlefish/host/commands/cvd/cli/commands/start.cpp b/base/cvd/cuttlefish/host/commands/cvd/cli/commands/start.cpp index ff1468b5f59..9b049eadb05 100644 --- a/base/cvd/cuttlefish/host/commands/cvd/cli/commands/start.cpp +++ b/base/cvd/cuttlefish/host/commands/cvd/cli/commands/start.cpp @@ -326,27 +326,47 @@ Result> GetCvdInternalStartFlags( return flags; } -} // namespace - -CvdStartCommandHandler::CvdStartCommandHandler( - InstanceManager& instance_manager) - : instance_manager_(instance_manager) { - own_flags_.daemon = true; -} +bool CanBypassToSingleInstance(const LocalInstance& instance, + const LocalInstanceGroup& group, + const std::vector& subcmd_args) { + if (instance.State() != cvd::INSTANCE_STATE_STOPPED) { + return false; + } + if (group.StartTime() == TimeStamp{}) { + return false; + } -static bool HasUnsafeFlagsForBypass(const std::vector& args) { - std::vector args_copy = args; + std::vector args_copy = subcmd_args; bool daemon = true; - std::string report_anonymous = ""; std::vector safe_flags = { GflagsCompatFlag("daemon", daemon), - GflagsCompatFlag("report_anonymous_usage_stats", report_anonymous), }; - auto res = ConsumeFlags(safe_flags, args_copy); - if (!res.ok()) { - return true; + const Result res = ConsumeFlags(safe_flags, args_copy); + if (!res.ok() || !daemon || !args_copy.empty()) { + return false; + } + + const std::vector& instances = group.Instances(); + if (instances.empty()) { + return false; + } + const LocalInstance& main_instance = instances[0]; + if (instance.Id() == main_instance.Id()) { + return false; } - return !args_copy.empty(); + if (main_instance.State() != cvd::INSTANCE_STATE_RUNNING) { + return false; + } + + return true; +} + +} // namespace + +CvdStartCommandHandler::CvdStartCommandHandler( + InstanceManager& instance_manager) + : instance_manager_(instance_manager) { + own_flags_.daemon = true; } Result CvdStartCommandHandler::Handle(const CommandRequest& request) { @@ -364,13 +384,11 @@ Result CvdStartCommandHandler::Handle(const CommandRequest& request) { auto [instance, group] = CF_EXPECT(selector::SelectInstance(instance_manager_, request)); - if (instance.State() == cvd::INSTANCE_STATE_STOPPED && - group.StartTime() != TimeStamp{} && - !HasUnsafeFlagsForBypass(subcmd_args)) { + if (CanBypassToSingleInstance(instance, group, subcmd_args)) { CF_EXPECT(LaunchSingleInstance(instance, group, request)); return {}; } else { - VLOG(1) << "Instance is not in stopped state. Proceeding with " + VLOG(1) << "Cannot bypass to single instance start. Proceeding with " "normal group start."; } }