wasmtime 20.0.2 → 22.0.0

data/ext/cargo-vendor/wasmtime-fiber-22.0.0/src/unix.rs

@@ -0,0 +1,494 @@
+//! The unix fiber implementation has some platform-specific details
+//! (naturally) but there's a few details of the stack layout which are common
+//! amongst all platforms using this file. Remember that none of this applies to
+//! Windows, which is entirely separate.
+//!
+//! The stack is expected to look pretty standard with a guard page at the end.
+//! Currently allocation happens in this file but this is probably going to be
+//! refactored to happen somewhere else. Otherwise though the stack layout is
+//! expected to look like so:
+//!
+//!
+//! ```text
+//! 0xB000 +-----------------------+   <- top of stack
+//!        | &Cell<RunResult>      |   <- where to store results
+//! 0xAff8 +-----------------------+
+//!        | *const u8             |   <- last sp to resume from
+//! 0xAff0 +-----------------------+   <- 16-byte aligned
+//!        |                       |
+//!        ~        ...            ~   <- actual native stack space to use
+//!        |                       |
+//! 0x1000 +-----------------------+
+//!        |  guard page           |
+//! 0x0000 +-----------------------+
+//! ```
+//!
+//! Here `0xAff8` is filled in temporarily while `resume` is running. The fiber
+//! started with 0xB000 as a parameter so it knows how to find this.
+//! Additionally `resumes` stores state at 0xAff0 to restart execution, and
+//! `suspend`, which has 0xB000 so it can find this, will read that and write
+//! its own resumption information into this slot as well.
+
+use crate::{RunResult, RuntimeFiberStack};
+use std::cell::Cell;
+use std::io;
+use std::ops::Range;
+use std::ptr;
+
+pub struct FiberStack {
+    base: *mut u8,
+    len: usize,
+
+    /// Stored here to ensure that when this `FiberStack` the backing storage,
+    /// if any, is additionally dropped.
+    storage: FiberStackStorage,
+}
+
+enum FiberStackStorage {
+    Mmap(#[allow(dead_code)] MmapFiberStack),
+    Unmanaged,
+    Custom(#[allow(dead_code)] Box<dyn RuntimeFiberStack>),
+}
+
+impl FiberStack {
+    pub fn new(size: usize) -> io::Result<Self> {
+        // See comments in `mod asan` below for why asan has a different stack
+        // allocation strategy.
+        if cfg!(asan) {
+            return Self::from_custom(asan::new_fiber_stack(size)?);
+        }
+        let page_size = rustix::param::page_size();
+        let stack = MmapFiberStack::new(size)?;
+
+        // An `MmapFiberStack` allocates a guard page at the bottom of the
+        // region so the base and length of our stack are both offset by a
+        // single page.
+        Ok(FiberStack {
+            base: stack.mapping_base.wrapping_byte_add(page_size),
+            len: stack.mapping_len - page_size,
+            storage: FiberStackStorage::Mmap(stack),
+        })
+    }
+
+    pub unsafe fn from_raw_parts(base: *mut u8, len: usize) -> io::Result<Self> {
+        // See comments in `mod asan` below for why asan has a different stack
+        // allocation strategy.
+        if cfg!(asan) {
+            return Self::from_custom(asan::new_fiber_stack(len)?);
+        }
+        Ok(FiberStack {
+            base,
+            len,
+            storage: FiberStackStorage::Unmanaged,
+        })
+    }
+
+    pub fn is_from_raw_parts(&self) -> bool {
+        matches!(self.storage, FiberStackStorage::Unmanaged)
+    }
+
+    pub fn from_custom(custom: Box<dyn RuntimeFiberStack>) -> io::Result<Self> {
+        let range = custom.range();
+        let page_size = rustix::param::page_size();
+        let start_ptr = range.start as *mut u8;
+        assert!(
+            start_ptr.align_offset(page_size) == 0,
+            "expected fiber stack base ({start_ptr:?}) to be page aligned ({page_size:#x})",
+        );
+        let end_ptr = range.end as *const u8;
+        assert!(
+            end_ptr.align_offset(page_size) == 0,
+            "expected fiber stack end ({end_ptr:?}) to be page aligned ({page_size:#x})",
+        );
+        Ok(FiberStack {
+            base: start_ptr,
+            len: range.len(),
+            storage: FiberStackStorage::Custom(custom),
+        })
+    }
+
+    pub fn top(&self) -> Option<*mut u8> {
+        Some(self.base.wrapping_byte_add(self.len))
+    }
+
+    pub fn range(&self) -> Option<Range<usize>> {
+        let base = self.base as usize;
+        Some(base..base + self.len)
+    }
+}
+
+struct MmapFiberStack {
+    mapping_base: *mut u8,
+    mapping_len: usize,
+}
+
+unsafe impl Send for MmapFiberStack {}
+unsafe impl Sync for MmapFiberStack {}
+
+impl MmapFiberStack {
+    fn new(size: usize) -> io::Result<Self> {
+        // Round up our stack size request to the nearest multiple of the
+        // page size.
+        let page_size = rustix::param::page_size();
+        let size = if size == 0 {
+            page_size
+        } else {
+            (size + (page_size - 1)) & (!(page_size - 1))
+        };
+
+        unsafe {
+            // Add in one page for a guard page and then ask for some memory.
+            let mmap_len = size + page_size;
+            let mmap = rustix::mm::mmap_anonymous(
+                ptr::null_mut(),
+                mmap_len,
+                rustix::mm::ProtFlags::empty(),
+                rustix::mm::MapFlags::PRIVATE,
+            )?;
+
+            rustix::mm::mprotect(
+                mmap.byte_add(page_size),
+                size,
+                rustix::mm::MprotectFlags::READ | rustix::mm::MprotectFlags::WRITE,
+            )?;
+
+            Ok(MmapFiberStack {
+                mapping_base: mmap.cast(),
+                mapping_len: mmap_len,
+            })
+        }
+    }
+}
+
+impl Drop for MmapFiberStack {
+    fn drop(&mut self) {
+        unsafe {
+            let ret = rustix::mm::munmap(self.mapping_base.cast(), self.mapping_len);
+            debug_assert!(ret.is_ok());
+        }
+    }
+}
+
+pub struct Fiber;
+
+pub struct Suspend {
+    top_of_stack: *mut u8,
+    previous: asan::PreviousStack,
+}
+
+extern "C" {
+    #[wasmtime_versioned_export_macros::versioned_link]
+    fn wasmtime_fiber_init(
+        top_of_stack: *mut u8,
+        entry: extern "C" fn(*mut u8, *mut u8),
+        entry_arg0: *mut u8,
+    );
+    #[wasmtime_versioned_export_macros::versioned_link]
+    fn wasmtime_fiber_switch(top_of_stack: *mut u8);
+    #[allow(dead_code)] // only used in inline assembly for some platforms
+    #[wasmtime_versioned_export_macros::versioned_link]
+    fn wasmtime_fiber_start();
+}
+
+extern "C" fn fiber_start<F, A, B, C>(arg0: *mut u8, top_of_stack: *mut u8)
+where
+    F: FnOnce(A, &mut super::Suspend<A, B, C>) -> C,
+{
+    unsafe {
+        // Complete the `start_switch` AddressSanitizer handshake which would
+        // have been started in `Fiber::resume`.
+        let previous = asan::fiber_start_complete();
+
+        let inner = Suspend {
+            top_of_stack,
+            previous,
+        };
+        let initial = inner.take_resume::<A, B, C>();
+        super::Suspend::<A, B, C>::execute(inner, initial, Box::from_raw(arg0.cast::<F>()))
+    }
+}
+
+impl Fiber {
+    pub fn new<F, A, B, C>(stack: &FiberStack, func: F) -> io::Result<Self>
+    where
+        F: FnOnce(A, &mut super::Suspend<A, B, C>) -> C,
+    {
+        unsafe {
+            let data = Box::into_raw(Box::new(func)).cast();
+            wasmtime_fiber_init(stack.top().unwrap(), fiber_start::<F, A, B, C>, data);
+        }
+
+        Ok(Self)
+    }
+
+    pub(crate) fn resume<A, B, C>(&self, stack: &FiberStack, result: &Cell<RunResult<A, B, C>>) {
+        unsafe {
+            // Store where our result is going at the very tip-top of the
+            // stack, otherwise known as our reserved slot for this information.
+            //
+            // In the diagram above this is updating address 0xAff8
+            let addr = stack.top().unwrap().cast::<usize>().offset(-1);
+            addr.write(result as *const _ as usize);
+
+            asan::fiber_switch(
+                stack.top().unwrap(),
+                false,
+                &mut asan::PreviousStack::new(stack),
+            );
+
+            // null this out to help catch use-after-free
+            addr.write(0);
+        }
+    }
+}
+
+impl Suspend {
+    pub(crate) fn switch<A, B, C>(&mut self, result: RunResult<A, B, C>) -> A {
+        unsafe {
+            let is_finishing = match &result {
+                RunResult::Returned(_) | RunResult::Panicked(_) => true,
+                RunResult::Executing | RunResult::Resuming(_) | RunResult::Yield(_) => false,
+            };
+            // Calculate 0xAff8 and then write to it
+            (*self.result_location::<A, B, C>()).set(result);
+
+            asan::fiber_switch(self.top_of_stack, is_finishing, &mut self.previous);
+
+            self.take_resume::<A, B, C>()
+        }
+    }
+
+    unsafe fn take_resume<A, B, C>(&self) -> A {
+        match (*self.result_location::<A, B, C>()).replace(RunResult::Executing) {
+            RunResult::Resuming(val) => val,
+            _ => panic!("not in resuming state"),
+        }
+    }
+
+    unsafe fn result_location<A, B, C>(&self) -> *const Cell<RunResult<A, B, C>> {
+        let ret = self.top_of_stack.cast::<*const u8>().offset(-1).read();
+        assert!(!ret.is_null());
+        ret.cast()
+    }
+}
+
+cfg_if::cfg_if! {
+    if #[cfg(target_arch = "aarch64")] {
+        mod aarch64;
+    } else if #[cfg(target_arch = "x86_64")] {
+        mod x86_64;
+    } else if #[cfg(target_arch = "x86")] {
+        mod x86;
+    } else if #[cfg(target_arch = "arm")] {
+        mod arm;
+    } else if #[cfg(target_arch = "s390x")] {
+        // currently `global_asm!` isn't stable on s390x so this is an external
+        // assembler file built with the `build.rs`.
+    } else if #[cfg(target_arch = "riscv64")]  {
+        mod riscv64;
+    } else {
+        compile_error!("fibers are not supported on this CPU architecture");
+    }
+}
+
+/// Support for AddressSanitizer to support stack manipulations we do in this
+/// fiber implementation.
+///
+/// This module uses, when fuzzing is enabled, special intrinsics provided by
+/// the sanitizer runtime called `__sanitizer_{start,finish}_switch_fiber`.
+/// These aren't really super heavily documented and the current implementation
+/// is inspired by googling the functions and looking at Boost & Julia's usage
+/// of them as well as the documentation for these functions in their own
+/// header file in the LLVM source tree. The general idea is that they're
+/// called around every stack switch with some other fiddly bits as well.
+#[cfg(asan)]
+mod asan {
+    use super::{FiberStack, MmapFiberStack, RuntimeFiberStack};
+    use rustix::param::page_size;
+    use std::mem::ManuallyDrop;
+    use std::ops::Range;
+    use std::sync::Mutex;
+
+    /// State for the "previous stack" maintained by asan itself and fed in for
+    /// custom stacks.
+    pub struct PreviousStack {
+        bottom: *const u8,
+        size: usize,
+    }
+
+    impl PreviousStack {
+        pub fn new(stack: &FiberStack) -> PreviousStack {
+            let range = stack.range().unwrap();
+            PreviousStack {
+                bottom: range.start as *const u8,
+                // Discount the two pointers we store at the top of the stack,
+                // so subtract two pointers.
+                size: range.len() - 2 * std::mem::size_of::<*const u8>(),
+            }
+        }
+    }
+
+    impl Default for PreviousStack {
+        fn default() -> PreviousStack {
+            PreviousStack {
+                bottom: std::ptr::null(),
+                size: 0,
+            }
+        }
+    }
+
+    /// Switches the current stack to `top_of_stack`
+    ///
+    /// * `top_of_stack` - for going to fibers this is calculated and for
+    ///   restoring back to the original stack this was saved during the initial
+    ///   transition.
+    /// * `is_finishing` - whether or not we're switching off a fiber for the
+    ///   final time; customizes how asan intrinsics are invoked.
+    /// * `prev` - the stack we're switching to initially and saves the
+    ///   stack to return to upon resumption.
+    pub unsafe fn fiber_switch(
+        top_of_stack: *mut u8,
+        is_finishing: bool,
+        prev: &mut PreviousStack,
+    ) {
+        let mut private_asan_pointer = std::ptr::null_mut();
+
+        // If this fiber is finishing then NULL is passed to asan to let it know
+        // that it can deallocate the "fake stack" that it's tracking for this
+        // fiber.
+        let private_asan_pointer_ref = if is_finishing {
+            None
+        } else {
+            Some(&mut private_asan_pointer)
+        };
+
+        // NB: in fiddling with asan an optimizations and such it appears that
+        // these functions need to be "very close to each other". If other Rust
+        // functions are invoked or added as an abstraction here that appears to
+        // trigger false positives in ASAN. That leads to the design of this
+        // module as-is where this function exists to have these three
+        // functions very close to one another.
+        __sanitizer_start_switch_fiber(private_asan_pointer_ref, prev.bottom, prev.size);
+        super::wasmtime_fiber_switch(top_of_stack);
+        __sanitizer_finish_switch_fiber(private_asan_pointer, &mut prev.bottom, &mut prev.size);
+    }
+
+    /// Hook for when a fiber first starts, used to configure ASAN.
+    pub unsafe fn fiber_start_complete() -> PreviousStack {
+        let mut ret = PreviousStack::default();
+        __sanitizer_finish_switch_fiber(std::ptr::null_mut(), &mut ret.bottom, &mut ret.size);
+        ret
+    }
+
+    // These intrinsics are provided by the address sanitizer runtime. Their C
+    // signatures were translated into Rust-isms here with `Option` and `&mut`.
+    extern "C" {
+        fn __sanitizer_start_switch_fiber(
+            private_asan_pointer_save: Option<&mut *mut u8>,
+            bottom: *const u8,
+            size: usize,
+        );
+        fn __sanitizer_finish_switch_fiber(
+            private_asan_pointer: *mut u8,
+            bottom_old: &mut *const u8,
+            size_old: &mut usize,
+        );
+    }
+
+    /// This static is a workaround for llvm/llvm-project#53891, notably this is
+    /// a global cache of all fiber stacks.
+    ///
+    /// The problem with ASAN is that if we allocate memory for a stack, use it
+    /// as a stack, deallocate the stack, and then when that memory is later
+    /// mapped as normal heap memory. This is possible due to `mmap` reusing
+    /// addresses and it ends up confusing ASAN. In this situation ASAN will
+    /// have false positives about stack overflows saying that writes to
+    /// freshly-allocated memory, which just happened to historically be a
+    /// stack, are a stack overflow.
+    ///
+    /// This static works around the issue by ensuring that, only when asan is
+    /// enabled, all stacks are cached globally. Stacks are never deallocated
+    /// and forever retained here. This only works if the number of stacks
+    /// retained here is relatively small to prevent OOM from continuously
+    /// running programs. That's hopefully the case as ASAN is mostly used in
+    /// OSS-Fuzz and our fuzzers only fuzz one thing at a time per thread
+    /// meaning that this should only ever be a relatively small set of stacks.
+    static FIBER_STACKS: Mutex<Vec<MmapFiberStack>> = Mutex::new(Vec::new());
+
+    pub fn new_fiber_stack(size: usize) -> std::io::Result<Box<dyn RuntimeFiberStack>> {
+        let needed_size = size + page_size();
+        let mut stacks = FIBER_STACKS.lock().unwrap();
+
+        let stack = match stacks.iter().position(|i| needed_size <= i.mapping_len) {
+            // If an appropriately sized stack was already allocated, then use
+            // that one.
+            Some(i) => stacks.remove(i),
+            // ... otherwise allocate a brand new stack.
+            None => MmapFiberStack::new(size)?,
+        };
+        let stack = AsanFiberStack(ManuallyDrop::new(stack));
+        Ok(Box::new(stack))
+    }
+
+    /// Custom structure used to prevent the interior mmap-allocated stack from
+    /// actually getting unmapped.
+    ///
+    /// On drop this stack will return the interior stack to the global
+    /// `FIBER_STACKS` list.
+    struct AsanFiberStack(ManuallyDrop<MmapFiberStack>);
+
+    unsafe impl RuntimeFiberStack for AsanFiberStack {
+        fn top(&self) -> *mut u8 {
+            self.0.mapping_base.wrapping_byte_add(self.0.mapping_len)
+        }
+
+        fn range(&self) -> Range<usize> {
+            let base = self.0.mapping_base as usize;
+            let end = base + self.0.mapping_len;
+            base + page_size()..end
+        }
+    }
+
+    impl Drop for AsanFiberStack {
+        fn drop(&mut self) {
+            let stack = unsafe { ManuallyDrop::take(&mut self.0) };
+            FIBER_STACKS.lock().unwrap().push(stack);
+        }
+    }
+}
+
+// Shim module that's the same as above but only has stubs.
+#[cfg(not(asan))]
+mod asan_disabled {
+    use super::{FiberStack, RuntimeFiberStack};
+
+    #[derive(Default)]
+    pub struct PreviousStack;
+
+    impl PreviousStack {
+        #[inline]
+        pub fn new(_stack: &FiberStack) -> PreviousStack {
+            PreviousStack
+        }
+    }
+
+    pub unsafe fn fiber_switch(
+        top_of_stack: *mut u8,
+        _is_finishing: bool,
+        _prev: &mut PreviousStack,
+    ) {
+        super::wasmtime_fiber_switch(top_of_stack);
+    }
+
+    #[inline]
+    pub unsafe fn fiber_start_complete() -> PreviousStack {
+        PreviousStack
+    }
+
+    pub fn new_fiber_stack(_size: usize) -> std::io::Result<Box<dyn RuntimeFiberStack>> {
+        unimplemented!()
+    }
+}
+
+#[cfg(not(asan))]
+use asan_disabled as asan;

data/ext/cargo-vendor/wasmtime-fiber-22.0.0/src/windows.rs

@@ -0,0 +1,170 @@
+use crate::{RunResult, RuntimeFiberStack};
+use std::cell::Cell;
+use std::ffi::c_void;
+use std::io;
+use std::ops::Range;
+use std::ptr;
+use windows_sys::Win32::Foundation::*;
+use windows_sys::Win32::System::Threading::*;
+
+#[derive(Debug)]
+pub struct FiberStack(usize);
+
+impl FiberStack {
+    pub fn new(size: usize) -> io::Result<Self> {
+        Ok(Self(size))
+    }
+
+    pub unsafe fn from_raw_parts(_base: *mut u8, _len: usize) -> io::Result<Self> {
+        Err(io::Error::from_raw_os_error(ERROR_NOT_SUPPORTED as i32))
+    }
+
+    pub fn is_from_raw_parts(&self) -> bool {
+        false
+    }
+
+    pub fn from_custom(_custom: Box<dyn RuntimeFiberStack>) -> io::Result<Self> {
+        Err(io::Error::from_raw_os_error(ERROR_NOT_SUPPORTED as i32))
+    }
+
+    pub fn top(&self) -> Option<*mut u8> {
+        None
+    }
+
+    pub fn range(&self) -> Option<Range<usize>> {
+        None
+    }
+}
+
+pub struct Fiber {
+    fiber: *mut c_void,
+    state: Box<StartState>,
+}
+
+pub struct Suspend {
+    state: *const StartState,
+}
+
+struct StartState {
+    parent: Cell<*mut c_void>,
+    initial_closure: Cell<*mut u8>,
+    result_location: Cell<*const u8>,
+}
+
+const FIBER_FLAG_FLOAT_SWITCH: u32 = 1;
+
+extern "C" {
+    #[wasmtime_versioned_export_macros::versioned_link]
+    fn wasmtime_fiber_get_current() -> *mut c_void;
+}
+
+unsafe extern "system" fn fiber_start<F, A, B, C>(data: *mut c_void)
+where
+    F: FnOnce(A, &mut super::Suspend<A, B, C>) -> C,
+{
+    // Set the stack guarantee to be consistent with what Rust expects for threads
+    // This value is taken from:
+    // https://github.com/rust-lang/rust/blob/0d97f7a96877a96015d70ece41ad08bb7af12377/library/std/src/sys/windows/stack_overflow.rs
+    if SetThreadStackGuarantee(&mut 0x5000) == 0 {
+        panic!("failed to set fiber stack guarantee");
+    }
+
+    let state = data.cast::<StartState>();
+    let func = Box::from_raw((*state).initial_closure.get().cast::<F>());
+    (*state).initial_closure.set(ptr::null_mut());
+    let suspend = Suspend { state };
+    let initial = suspend.take_resume::<A, B, C>();
+    super::Suspend::<A, B, C>::execute(suspend, initial, *func);
+}
+
+impl Fiber {
+    pub fn new<F, A, B, C>(stack: &FiberStack, func: F) -> io::Result<Self>
+    where
+        F: FnOnce(A, &mut super::Suspend<A, B, C>) -> C,
+    {
+        unsafe {
+            let state = Box::new(StartState {
+                initial_closure: Cell::new(Box::into_raw(Box::new(func)).cast()),
+                parent: Cell::new(ptr::null_mut()),
+                result_location: Cell::new(ptr::null()),
+            });
+
+            let fiber = CreateFiberEx(
+                0,
+                stack.0,
+                FIBER_FLAG_FLOAT_SWITCH,
+                Some(fiber_start::<F, A, B, C>),
+                &*state as *const StartState as *mut _,
+            );
+
+            if fiber.is_null() {
+                drop(Box::from_raw(state.initial_closure.get().cast::<F>()));
+                return Err(io::Error::last_os_error());
+            }
+
+            Ok(Self { fiber, state })
+        }
+    }
+
+    pub(crate) fn resume<A, B, C>(&self, _stack: &FiberStack, result: &Cell<RunResult<A, B, C>>) {
+        unsafe {
+            let is_fiber = IsThreadAFiber() != 0;
+            let parent_fiber = if is_fiber {
+                wasmtime_fiber_get_current()
+            } else {
+                ConvertThreadToFiber(ptr::null_mut())
+            };
+            assert!(
+                !parent_fiber.is_null(),
+                "failed to make current thread a fiber"
+            );
+            self.state
+                .result_location
+                .set(result as *const _ as *const _);
+            self.state.parent.set(parent_fiber);
+            SwitchToFiber(self.fiber);
+            self.state.parent.set(ptr::null_mut());
+            self.state.result_location.set(ptr::null());
+            if !is_fiber {
+                let res = ConvertFiberToThread();
+                assert!(res != 0, "failed to convert main thread back");
+            }
+        }
+    }
+}
+
+impl Drop for Fiber {
+    fn drop(&mut self) {
+        unsafe {
+            DeleteFiber(self.fiber);
+        }
+    }
+}
+
+impl Suspend {
+    pub(crate) fn switch<A, B, C>(&self, result: RunResult<A, B, C>) -> A {
+        unsafe {
+            (*self.result_location::<A, B, C>()).set(result);
+            debug_assert!(IsThreadAFiber() != 0);
+            let parent = (*self.state).parent.get();
+            debug_assert!(!parent.is_null());
+            SwitchToFiber(parent);
+            self.take_resume::<A, B, C>()
+        }
+    }
+    unsafe fn take_resume<A, B, C>(&self) -> A {
+        match (*self.result_location::<A, B, C>()).replace(RunResult::Executing) {
+            RunResult::Resuming(val) => val,
+            _ => panic!("not in resuming state"),
+        }
+    }
+
+    unsafe fn result_location<A, B, C>(&self) -> *const Cell<RunResult<A, B, C>> {
+        let ret = (*self.state)
+            .result_location
+            .get()
+            .cast::<Cell<RunResult<A, B, C>>>();
+        assert!(!ret.is_null());
+        return ret;
+    }
+}

data/ext/cargo-vendor/wasmtime-jit-debug-22.0.0/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"47d0b4203031fee8c8da3becc59dc0529d95c28b75ddb701e1e8ecf6aa235dd4","README.md":"8d4c2672c511d7841784444d71651693c38e408dff63311c38d0535e26884a5b","src/gdb_jit_int.rs":"bac530e0916203cedbe03536546929b3bda2290e834443fdb0b8dcb0e13b50d2","src/lib.rs":"57cae0ed92cd899534bd01ab357e3fd399fea70ea3e753bef3daf8714f1ed289","src/perf_jitdump.rs":"e681a0cb681142eeaf8b0e697ec200a0e7539e36293d9fce2412d1b2901a2072"},"package":"9bc54198c6720f098210a85efb3ba8c078d1de4d373cdb6778850a66ae088d11"}