diff --git a/apps/demo/package.json b/apps/demo/package.json
index 9d813e3a7..4634724c0 100644
--- a/apps/demo/package.json
+++ b/apps/demo/package.json
@@ -29,7 +29,7 @@
     "@nativescript/canvas-svg": "file:../../packages/canvas-svg"
   },
   "devDependencies": {
-    "@nativescript/android": "alpha",
+    "@nativescript/android": "8.7.0",
     "@nativescript/ios": "8.7.0",
     "@nativescript/visionos": "8.6.0"
   }
diff --git a/crates/canvas-c/Cargo.toml b/crates/canvas-c/Cargo.toml
index 7f1a7eb6f..0b0fb2677 100644
--- a/crates/canvas-c/Cargo.toml
+++ b/crates/canvas-c/Cargo.toml
@@ -19,6 +19,7 @@ log = { version = "0.4.20"}
 wgpu-types = "0.20.0"
 futures = "0.3"
 raw-window-handle = "0.6.2"
+wgpu-core = {version = "0.21.0", features = ["wgsl","vulkan","metal","raw-window-handle"]}
 
 [target.'cfg(target_os="ios")'.dependencies]
 display-link = {version = "0.2.0"}
diff --git a/crates/canvas-c/src/webgpu/enums.rs b/crates/canvas-c/src/webgpu/enums.rs
index 2e524ac95..772b3dca3 100644
--- a/crates/canvas-c/src/webgpu/enums.rs
+++ b/crates/canvas-c/src/webgpu/enums.rs
@@ -3,6 +3,14 @@ use std::{
     os::raw::c_char,
 };
 
+use wgpu_core::binding_model::{BindGroupEntry, BufferBinding};
+use wgpu_types::{AddressMode, BindGroupLayoutEntry, BufferBindingType, CompareFunction, Features, FilterMode, QueryType, SamplerBindingType, StorageTextureAccess, TextureSampleType};
+use wgpu_types::BindingType::Sampler;
+
+use crate::webgpu::gpu_buffer::CanvasGPUBuffer;
+use crate::webgpu::gpu_sampler::CanvasGPUSampler;
+use crate::webgpu::gpu_texture_view::CanvasGPUTextureView;
+
 #[repr(C)]
 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
 pub enum CanvasTextureDimension {
@@ -981,17 +989,17 @@ pub unsafe extern "C" fn canvas_native_webgpu_string_to_gpu_texture_enum(
                     return CanvasOptionalGPUTextureFormat::Some(CanvasGPUTextureFormat::Astc {
                         block,
                         channel,
-                    })
+                    });
                 }
 
                 CanvasOptionalGPUTextureFormat::None
             } else {
-             CanvasOptionalGPUTextureFormat::None
+                CanvasOptionalGPUTextureFormat::None
             }
         }
     };
 
-    return format
+    return format;
 }
 
 /// ASTC block dimensions
@@ -1714,3 +1722,461 @@ impl Into<Option<wgpu_types::FrontFace>> for CanvasOptionalFrontFace {
         }
     }
 }
+
+
+#[repr(C)]
+pub struct CanvasBufferBinding {
+    pub buffer: *const CanvasGPUBuffer,
+    pub offset: i64,
+    pub size: i64,
+}
+
+impl Into<BufferBinding> for CanvasBufferBinding {
+    fn into(self) -> BufferBinding {
+        use std::num::NonZeroU64;
+        let buffer = unsafe { &*self.buffer };
+        let buffer_id = buffer.buffer;
+        BufferBinding {
+            buffer_id,
+            offset: self.offset.try_into().unwrap_or_default(),
+            size: self.size.try_into()
+                .map(|value: u64| NonZeroU64::new(value))
+                .ok()
+                .flatten(),
+        }
+    }
+}
+
+#[repr(C)]
+pub enum CanvasBindGroupEntryResource {
+    Buffer(CanvasBufferBinding),
+    Sampler(*const CanvasGPUSampler),
+    TextureView(*const CanvasGPUTextureView),
+}
+
+#[repr(C)]
+pub struct CanvasBindGroupEntry {
+    pub binding: u32,
+    pub resource: CanvasBindGroupEntryResource,
+}
+
+impl Into<BindGroupEntry<'static>> for CanvasBindGroupEntry {
+    fn into(self) -> BindGroupEntry<'static> {
+        match self.resource {
+            CanvasBindGroupEntryResource::Buffer(buffer) => BindGroupEntry { binding: self.binding, resource: wgpu_core::binding_model::BindingResource::Buffer(buffer.into()) },
+            CanvasBindGroupEntryResource::Sampler(sampler) => {
+                let sampler = unsafe { &*sampler };
+                let sampler_id = sampler.sampler;
+                BindGroupEntry {
+                    binding: self.binding,
+                    resource: wgpu_core::binding_model::BindingResource::Sampler(sampler_id),
+                }
+            }
+            CanvasBindGroupEntryResource::TextureView(view) => {
+                let view = unsafe { &*view };
+                let view_id = view.texture_view;
+                BindGroupEntry {
+                    binding: self.binding,
+                    resource: wgpu_core::binding_model::BindingResource::TextureView(view_id),
+                }
+            }
+        }
+    }
+}
+
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
+pub enum CanvasStorageTextureAccess {
+    /// The texture can only be written in the shader and it:
+    /// - may or may not be annotated with `write` (WGSL).
+    /// - must be annotated with `writeonly` (GLSL).
+    ///
+    /// Example WGSL syntax:
+    /// ```rust,ignore
+    /// @group(0) @binding(0)
+    /// var my_storage_image: texture_storage_2d<f32, write>;
+    /// ```
+    ///
+    /// Example GLSL syntax:
+    /// ```cpp,ignore
+    /// layout(set=0, binding=0, r32f) writeonly uniform image2D myStorageImage;
+    /// ```
+    WriteOnly,
+    /// The texture can only be read in the shader and it must be annotated with `read` (WGSL) or
+    /// `readonly` (GLSL).
+    ///
+    /// [`Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES`] must be enabled to use this access
+    /// mode. This is a native-only extension.
+    ///
+    /// Example WGSL syntax:
+    /// ```rust,ignore
+    /// @group(0) @binding(0)
+    /// var my_storage_image: texture_storage_2d<f32, read>;
+    /// ```
+    ///
+    /// Example GLSL syntax:
+    /// ```cpp,ignore
+    /// layout(set=0, binding=0, r32f) readonly uniform image2D myStorageImage;
+    /// ```
+    ReadOnly,
+    /// The texture can be both read and written in the shader and must be annotated with
+    /// `read_write` in WGSL.
+    ///
+    /// [`Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES`] must be enabled to use this access
+    /// mode.  This is a nonstandard, native-only extension.
+    ///
+    /// Example WGSL syntax:
+    /// ```rust,ignore
+    /// @group(0) @binding(0)
+    /// var my_storage_image: texture_storage_2d<f32, read_write>;
+    /// ```
+    ///
+    /// Example GLSL syntax:
+    /// ```cpp,ignore
+    /// layout(set=0, binding=0, r32f) uniform image2D myStorageImage;
+    /// ```
+    ReadWrite,
+}
+
+impl From<StorageTextureAccess> for CanvasStorageTextureAccess {
+    fn from(value: StorageTextureAccess) -> Self {
+        match value {
+            StorageTextureAccess::WriteOnly => Self::WriteOnly,
+            StorageTextureAccess::ReadOnly => Self::ReadOnly,
+            StorageTextureAccess::ReadWrite => Self::ReadWrite,
+        }
+    }
+}
+
+impl Into<StorageTextureAccess> for CanvasStorageTextureAccess {
+    fn into(self) -> StorageTextureAccess {
+        match self {
+            CanvasStorageTextureAccess::WriteOnly => StorageTextureAccess::WriteOnly,
+            CanvasStorageTextureAccess::ReadOnly => StorageTextureAccess::ReadOnly,
+            CanvasStorageTextureAccess::ReadWrite => StorageTextureAccess::ReadWrite
+        }
+    }
+}
+
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug)]
+pub struct CanvasTextureBindingLayout {
+    sample_type: CanvasTextureSampleType,
+    view_dimension: CanvasTextureViewDimension,
+    multisampled: bool,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug)]
+pub enum CanvasTextureSampleType {
+    Float,
+    UnfilterableFloat,
+    Depth,
+    Sint,
+    Uint,
+}
+
+impl From<TextureSampleType> for CanvasTextureSampleType {
+    fn from(sample_type: TextureSampleType) -> Self {
+        match sample_type {
+            TextureSampleType::Float { filterable } => {
+                if filterable {
+                    Self::Float
+                } else {
+                    Self::UnfilterableFloat
+                }
+            }
+            TextureSampleType::Depth => Self::Depth,
+            TextureSampleType::Sint => Self::Sint,
+            TextureSampleType::Uint => Self::Uint
+        }
+    }
+}
+
+impl Into<TextureSampleType> for CanvasTextureSampleType {
+    fn into(self) -> TextureSampleType {
+        match self {
+            CanvasTextureSampleType::Float => TextureSampleType::Float { filterable: true },
+            CanvasTextureSampleType::UnfilterableFloat => TextureSampleType::Float { filterable: false },
+            CanvasTextureSampleType::Depth => TextureSampleType::Depth,
+            CanvasTextureSampleType::Sint => TextureSampleType::Sint,
+            CanvasTextureSampleType::Uint => TextureSampleType::Uint
+        }
+    }
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug)]
+pub struct CanvasStorageTextureBindingLayout {
+    access: CanvasStorageTextureAccess,
+    format: CanvasGPUTextureFormat,
+    view_dimension: CanvasTextureViewDimension,
+}
+
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
+pub enum CanvasSamplerBindingType {
+    /// The sampling result is produced based on more than a single color sample from a texture,
+    /// e.g. when bilinear interpolation is enabled.
+    Filtering,
+    /// The sampling result is produced based on a single color sample from a texture.
+    NonFiltering,
+    /// Use as a comparison sampler instead of a normal sampler.
+    /// For more info take a look at the analogous functionality in OpenGL: <https://www.khronos.org/opengl/wiki/Sampler_Object#Comparison_mode>.
+    Comparison,
+}
+
+impl From<SamplerBindingType> for CanvasSamplerBindingType {
+    fn from(value: SamplerBindingType) -> Self {
+        match value {
+            SamplerBindingType::Filtering => Self::Filtering,
+            SamplerBindingType::NonFiltering => Self::NonFiltering,
+            SamplerBindingType::Comparison => Self::Comparison,
+        }
+    }
+}
+
+impl Into<SamplerBindingType> for CanvasSamplerBindingType {
+    fn into(self) -> SamplerBindingType {
+        match self {
+            CanvasSamplerBindingType::Filtering => SamplerBindingType::Filtering,
+            CanvasSamplerBindingType::NonFiltering => SamplerBindingType::NonFiltering,
+            CanvasSamplerBindingType::Comparison => SamplerBindingType::Comparison,
+        }
+    }
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug)]
+pub struct CanvasSamplerBindingLayout {
+    type_: CanvasSamplerBindingType,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug)]
+pub struct CanvasBufferBindingLayout {
+    type_: CanvasBufferBindingType,
+    has_dynamic_offset: bool,
+    min_binding_size: i64,
+}
+
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug)]
+pub enum CanvasBufferBindingType {
+    Uniform,
+    Storage,
+    ReadOnlyStorage,
+}
+
+impl From<BufferBindingType> for CanvasBufferBindingType {
+    fn from(value: BufferBindingType) -> Self {
+        match value {
+            BufferBindingType::Uniform => Self::Uniform,
+            BufferBindingType::Storage { read_only } => {
+                if read_only {
+                    Self::ReadOnlyStorage
+                } else {
+                    Self::Storage
+                }
+            }
+        }
+    }
+}
+
+impl Into<BufferBindingType> for CanvasBufferBindingType {
+    fn into(self) -> BufferBindingType {
+        match self {
+            CanvasBufferBindingType::Uniform => BufferBindingType::Uniform,
+            CanvasBufferBindingType::Storage => BufferBindingType::Storage { read_only: false },
+            CanvasBufferBindingType::ReadOnlyStorage => BufferBindingType::Storage { read_only: true }
+        }
+    }
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug)]
+pub enum CanvasBindingType {
+    Buffer(CanvasBufferBindingLayout),
+    Sampler(CanvasSamplerBindingLayout),
+    Texture(CanvasTextureBindingLayout),
+    StorageTexture(CanvasStorageTextureBindingLayout),
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug)]
+pub struct CanvasBindGroupLayoutEntry {
+    binding: u32,
+    visibility: u32,
+    binding_type: CanvasBindingType,
+}
+
+impl Into<BindGroupLayoutEntry> for CanvasBindGroupLayoutEntry {
+    fn into(self) -> BindGroupLayoutEntry {
+        use std::num::NonZeroU64;
+        BindGroupLayoutEntry {
+            binding: self.binding,
+            visibility: wgpu_types::ShaderStages::from_bits(self.visibility).unwrap(),
+            ty: match self.binding_type {
+                CanvasBindingType::Buffer(buffer) => {
+                    wgpu_types::BindingType::Buffer {
+                        ty: buffer.type_.into(),
+                        has_dynamic_offset: buffer.has_dynamic_offset,
+                        min_binding_size: buffer.min_binding_size.try_into()
+                            .map(|value: u64| NonZeroU64::new(value))
+                            .ok()
+                            .flatten()
+                            
+                            
+                        ,
+                    }
+                }
+                CanvasBindingType::Sampler(sampler) => {
+                    wgpu_types::BindingType::Sampler(sampler.type_.into())
+                }
+                CanvasBindingType::Texture(texture) => {
+                    wgpu_types::BindingType::Texture {
+                        sample_type: texture.sample_type.into(),
+                        view_dimension: texture.view_dimension.into(),
+                        multisampled: texture.multisampled,
+                    }
+                }
+                CanvasBindingType::StorageTexture(storage_texture) => {
+                    wgpu_types::BindingType::StorageTexture {
+                        access: storage_texture.access.into(),
+                        format: storage_texture.format.into(),
+                        view_dimension: storage_texture.view_dimension.into(),
+                    }
+                }
+            },
+            count: None, // native-only
+        }
+    }
+}
+
+
+#[repr(C)]
+pub enum CanvasQueryType {
+    Occlusion,
+    Timestamp,
+}
+
+impl Into<wgpu_types::QueryType> for CanvasQueryType {
+    fn into(self) -> QueryType {
+        match self {
+            CanvasQueryType::Occlusion => QueryType::Occlusion,
+            CanvasQueryType::Timestamp => QueryType::Timestamp
+        }
+    }
+}
+
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug)]
+pub enum CanvasAddressMode {
+    /// Clamp the value to the edge of the texture
+    ///
+    /// -0.25 -> 0.0
+    /// 1.25  -> 1.0
+    ClampToEdge = 0,
+    /// Repeat the texture in a tiling fashion
+    ///
+    /// -0.25 -> 0.75
+    /// 1.25 -> 0.25
+    Repeat = 1,
+    /// Repeat the texture, mirroring it every repeat
+    ///
+    /// -0.25 -> 0.25
+    /// 1.25 -> 0.75
+    MirrorRepeat = 2,
+    /// Clamp the value to the border of the texture
+    /// Requires feature [`Features::ADDRESS_MODE_CLAMP_TO_BORDER`]
+    ///
+    /// -0.25 -> border
+    /// 1.25 -> border
+    ClampToBorder = 3,
+}
+
+
+impl Into<wgpu_types::AddressMode> for CanvasAddressMode {
+    fn into(self) -> AddressMode {
+        match self {
+            CanvasAddressMode::ClampToEdge => AddressMode::ClampToEdge,
+            CanvasAddressMode::Repeat => AddressMode::Repeat,
+            CanvasAddressMode::MirrorRepeat => AddressMode::MirrorRepeat,
+            CanvasAddressMode::ClampToBorder => AddressMode::ClampToBorder
+        }
+    }
+}
+
+impl From<wgpu_types::AddressMode> for CanvasAddressMode {
+    fn from(value: AddressMode) -> Self {
+        match value {
+            AddressMode::ClampToEdge => Self::ClampToEdge,
+            AddressMode::Repeat => Self::Repeat,
+            AddressMode::MirrorRepeat => Self::MirrorRepeat,
+            AddressMode::ClampToBorder => Self::ClampToBorder
+        }
+    }
+}
+
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug)]
+pub enum CanvasFilterMode {
+    Nearest = 0,
+    /// Linear Interpolation
+    ///
+    /// This makes textures smooth but blurry when used as a mag filter.
+    Linear = 1,
+}
+
+
+impl Into<wgpu_types::FilterMode> for CanvasFilterMode {
+    fn into(self) -> FilterMode {
+        match self {
+            CanvasFilterMode::Nearest => FilterMode::Nearest,
+            CanvasFilterMode::Linear => FilterMode::Linear
+        }
+    }
+}
+
+impl From<wgpu_types::FilterMode> for CanvasFilterMode {
+    fn from(value: FilterMode) -> Self {
+        match value {
+            FilterMode::Nearest => Self::Nearest,
+            FilterMode::Linear => Self::Linear
+        }
+    }
+}
+
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug)]
+pub enum CanvasOptionalCompareFunction {
+    None,
+    Some(CanvasCompareFunction),
+}
+
+impl Into<Option<wgpu_types::CompareFunction>> for CanvasOptionalCompareFunction {
+    fn into(self) -> Option<CompareFunction> {
+        match self {
+            CanvasOptionalCompareFunction::None => None,
+            CanvasOptionalCompareFunction::Some(value) => {
+                Some(value.into())
+            }
+        }
+    }
+}
+
+impl From<Option<wgpu_types::CompareFunction>> for CanvasOptionalCompareFunction {
+    fn from(value: Option<CompareFunction>) -> Self {
+        match value {
+            None => Self::None,
+            Some(value) => Self::Some(value.into())
+        }
+    }
+}
\ No newline at end of file
diff --git a/crates/canvas-c/src/webgpu/error.rs b/crates/canvas-c/src/webgpu/error.rs
new file mode 100644
index 000000000..14c10a820
--- /dev/null
+++ b/crates/canvas-c/src/webgpu/error.rs
@@ -0,0 +1,343 @@
+use std::error::Error;
+use std::ffi::CString;
+use std::fmt::Display;
+use std::os::raw::c_char;
+use std::sync::Arc;
+
+fn format_error(context: &Arc<wgpu_core::global::Global>, err: &(impl Error + 'static)) -> String {
+    let mut err_descs = vec![];
+
+    let mut err_str = String::new();
+    wgpu_core::error::format_pretty_any(&mut err_str, context, err);
+    err_descs.push(err_str);
+
+    let mut source_opt = err.source();
+    while let Some(source) = source_opt {
+        let mut source_str = String::new();
+        wgpu_core::error::format_pretty_any(&mut source_str, context, source);
+        err_descs.push(source_str);
+        source_opt = source.source();
+    }
+
+    format!("Validation Error\n\nCaused by:\n{}", err_descs.join(""))
+}
+
+pub(crate) fn handle_error(
+    context: &Arc<wgpu_core::global::Global>,
+    sink_mutex: &parking_lot::Mutex<crate::webgpu::gpu_device::ErrorSinkRaw>,
+    cause: impl Error + Send + Sync + 'static,
+    label_key: &'static str,
+    label: wgpu_core::Label,
+    string: &'static str,
+) {
+    let error = wgpu_core::error::ContextError {
+        string,
+        cause: Box::new(cause),
+        label: label.unwrap_or_default().to_string(),
+        label_key,
+    };
+    let mut sink = sink_mutex.lock();
+    let mut source_opt: Option<&(dyn Error + 'static)> = Some(&error);
+    while let Some(source) = source_opt {
+        match source.downcast_ref::<wgpu_core::device::DeviceError>() {
+            Some(wgpu_core::device::DeviceError::Lost) => {
+                return sink.handle_error(CanvasGPUError::Lost);
+            }
+            Some(wgpu_core::device::DeviceError::OutOfMemory) => {
+                return sink.handle_error(CanvasGPUError::OutOfMemory);
+            }
+            _ => (),
+        }
+        source_opt = source.source();
+    }
+
+    // Otherwise, it is a validation error
+    sink.handle_error(CanvasGPUError::Validation(error.to_string()));
+}
+
+pub(crate) fn handle_error_fatal(
+    global: &Arc<wgpu_core::global::Global>,
+    cause: impl Error + Send + Sync + 'static,
+    operation: &'static str,
+) {
+    // panic!(
+    //     "Error in {operation}: {f}",
+    //     f = format_error(context, &cause)
+    // );
+    log::error!("Error in {operation}: {f}",
+        f = format_error(global, &cause))
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum CanvasGPUErrorType {
+    None,
+    Lost,
+    OutOfMemory,
+    Validation,
+    Internal,
+}
+
+
+pub enum CanvasGPUError {
+    None,
+    Lost,
+    OutOfMemory,
+    Validation(String),
+    Internal,
+}
+
+impl Display for CanvasGPUError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            CanvasGPUError::Lost { .. } => f.write_str("Device lost"),
+            CanvasGPUError::OutOfMemory { .. } => f.write_str("Out of Memory"),
+            CanvasGPUError::Validation(value) => f.write_str(value),
+            CanvasGPUError::None => f.write_str(""),
+            CanvasGPUError::Internal => f.write_str("Internal")
+        }
+    }
+}
+
+
+fn fmt_err(err: &(dyn Error + 'static)) -> String {
+    let mut output = err.to_string();
+    let mut level = 0;
+
+    fn print_tree(output: &mut String, level: &mut usize, e: &(dyn Error + 'static)) {
+        use std::fmt::Write;
+
+        let mut print = |e: &(dyn Error + 'static)| {
+            writeln!(output, "{}{}", " ".repeat(*level * 2), e).unwrap();
+
+            if let Some(e) = e.source() {
+                *level += 1;
+                print_tree(output, level, e);
+                *level -= 1;
+            }
+        };
+        /*if let Some(multi) = e.downcast_ref::<wgpu_core::error::MultiError>() {
+            for e in multi.errors() {
+                print(e);
+            }
+        } else {
+            print(e);
+        }
+        */
+        print(e);
+    }
+
+    print_tree(&mut output, &mut level, err);
+
+    output
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn canvas_native_webgpu_error_get_type(error: *const CanvasGPUError) -> CanvasGPUErrorType {
+    let error = error.as_ref().expect("invalid error");
+    match error {
+        CanvasGPUError::Lost => CanvasGPUErrorType::Lost,
+        CanvasGPUError::OutOfMemory => CanvasGPUErrorType::OutOfMemory,
+        CanvasGPUError::Validation(_) => CanvasGPUErrorType::Validation,
+        CanvasGPUError::Internal => CanvasGPUErrorType::Internal,
+        CanvasGPUError::None => CanvasGPUErrorType::None
+    }
+}
+
+
+#[no_mangle]
+pub unsafe extern "C" fn canvas_native_webgpu_error_get_message(error: *const CanvasGPUError) -> *mut c_char {
+    let error = error.as_ref().expect("invalid error");
+    match error {
+        CanvasGPUError::Validation(value) => {
+            CString::new(value.to_string()).unwrap().into_raw()
+        }
+        _ => std::ptr::null_mut()
+    }
+}
+
+
+impl From<wgpu_core::device::DeviceError> for CanvasGPUError {
+    fn from(err: wgpu_core::device::DeviceError) -> Self {
+        match err {
+            wgpu_core::device::DeviceError::Lost => CanvasGPUError::Lost,
+            wgpu_core::device::DeviceError::OutOfMemory => CanvasGPUError::OutOfMemory,
+            _ => CanvasGPUError::Validation(fmt_err(&err)),
+        }
+    }
+}
+
+impl From<wgpu_core::pipeline::CreateRenderPipelineError> for CanvasGPUError {
+    fn from(value: wgpu_core::pipeline::CreateRenderPipelineError) -> Self {
+        match value {
+            wgpu_core::pipeline::CreateRenderPipelineError::Device(err) => err.into(),
+            err => CanvasGPUError::Validation(fmt_err(&err)),
+        }
+    }
+}
+
+impl From<wgpu_core::resource::CreateBufferError> for CanvasGPUError {
+    fn from(err: wgpu_core::resource::CreateBufferError) -> Self {
+        match err {
+            wgpu_core::resource::CreateBufferError::Device(err) => err.into(),
+            wgpu_core::resource::CreateBufferError::AccessError(err) => err.into(),
+            err => CanvasGPUError::Validation(fmt_err(&err)),
+        }
+    }
+}
+
+impl From<wgpu_core::resource::BufferAccessError> for CanvasGPUError {
+    fn from(err: wgpu_core::resource::BufferAccessError) -> Self {
+        match err {
+            wgpu_core::resource::BufferAccessError::Device(err) => err.into(),
+            err => CanvasGPUError::Validation(fmt_err(&err)),
+        }
+    }
+}
+
+impl From<wgpu_core::binding_model::CreateBindGroupLayoutError> for CanvasGPUError {
+    fn from(err: wgpu_core::binding_model::CreateBindGroupLayoutError) -> Self {
+        match err {
+            wgpu_core::binding_model::CreateBindGroupLayoutError::Device(err) => err.into(),
+            err => CanvasGPUError::Validation(fmt_err(&err)),
+        }
+    }
+}
+
+impl From<wgpu_core::binding_model::CreateBindGroupError> for CanvasGPUError {
+    fn from(err: wgpu_core::binding_model::CreateBindGroupError) -> Self {
+        match err {
+            wgpu_core::binding_model::CreateBindGroupError::Device(err) => err.into(),
+            err => CanvasGPUError::Validation(fmt_err(&err)),
+        }
+    }
+}
+
+impl From<wgpu_core::command::RenderBundleError> for CanvasGPUError {
+    fn from(err: wgpu_core::command::RenderBundleError) -> Self {
+        CanvasGPUError::Validation(fmt_err(&err))
+    }
+}
+
+impl From<wgpu_core::command::CreateRenderBundleError> for CanvasGPUError {
+    fn from(err: wgpu_core::command::CreateRenderBundleError) -> Self {
+        CanvasGPUError::Validation(fmt_err(&err))
+    }
+}
+
+impl From<wgpu_core::command::CopyError> for CanvasGPUError {
+    fn from(err: wgpu_core::command::CopyError) -> Self {
+        CanvasGPUError::Validation(fmt_err(&err))
+    }
+}
+
+impl From<wgpu_core::command::CommandEncoderError> for CanvasGPUError {
+    fn from(err: wgpu_core::command::CommandEncoderError) -> Self {
+        CanvasGPUError::Validation(fmt_err(&err))
+    }
+}
+
+impl From<wgpu_core::command::QueryError> for CanvasGPUError {
+    fn from(err: wgpu_core::command::QueryError) -> Self {
+        CanvasGPUError::Validation(fmt_err(&err))
+    }
+}
+
+impl From<wgpu_core::command::ComputePassError> for CanvasGPUError {
+    fn from(err: wgpu_core::command::ComputePassError) -> Self {
+        CanvasGPUError::Validation(fmt_err(&err))
+    }
+}
+
+impl From<wgpu_core::pipeline::CreateComputePipelineError> for CanvasGPUError {
+    fn from(err: wgpu_core::pipeline::CreateComputePipelineError) -> Self {
+        match err {
+            wgpu_core::pipeline::CreateComputePipelineError::Device(err) => err.into(),
+            err => CanvasGPUError::Validation(fmt_err(&err)),
+        }
+    }
+}
+
+impl From<wgpu_core::binding_model::GetBindGroupLayoutError> for CanvasGPUError {
+    fn from(err: wgpu_core::binding_model::GetBindGroupLayoutError) -> Self {
+        CanvasGPUError::Validation(fmt_err(&err))
+    }
+}
+
+impl From<wgpu_core::command::RenderPassError> for CanvasGPUError {
+    fn from(err: wgpu_core::command::RenderPassError) -> Self {
+        CanvasGPUError::Validation(fmt_err(&err))
+    }
+}
+
+impl From<wgpu_core::resource::CreateSamplerError> for CanvasGPUError {
+    fn from(err: wgpu_core::resource::CreateSamplerError) -> Self {
+        match err {
+            wgpu_core::resource::CreateSamplerError::Device(err) => err.into(),
+            err => CanvasGPUError::Validation(fmt_err(&err)),
+        }
+    }
+}
+
+impl From<wgpu_core::pipeline::CreateShaderModuleError> for CanvasGPUError {
+    fn from(err: wgpu_core::pipeline::CreateShaderModuleError) -> Self {
+        match err {
+            wgpu_core::pipeline::CreateShaderModuleError::Device(err) => err.into(),
+            err => CanvasGPUError::Validation(fmt_err(&err)),
+        }
+    }
+}
+
+impl From<wgpu_core::resource::CreateTextureError> for CanvasGPUError {
+    fn from(err: wgpu_core::resource::CreateTextureError) -> Self {
+        match err {
+            wgpu_core::resource::CreateTextureError::Device(err) => err.into(),
+            err => CanvasGPUError::Validation(fmt_err(&err)),
+        }
+    }
+}
+
+impl From<wgpu_core::resource::CreateTextureViewError> for CanvasGPUError {
+    fn from(err: wgpu_core::resource::CreateTextureViewError) -> Self {
+        CanvasGPUError::Validation(fmt_err(&err))
+    }
+}
+
+impl From<wgpu_core::resource::CreateQuerySetError> for CanvasGPUError {
+    fn from(err: wgpu_core::resource::CreateQuerySetError) -> Self {
+        match err {
+            wgpu_core::resource::CreateQuerySetError::Device(err) => err.into(),
+            err => CanvasGPUError::Validation(fmt_err(&err)),
+        }
+    }
+}
+
+impl From<wgpu_core::device::queue::QueueSubmitError> for CanvasGPUError {
+    fn from(err: wgpu_core::device::queue::QueueSubmitError) -> Self {
+        match err {
+            wgpu_core::device::queue::QueueSubmitError::Queue(err) => err.into(),
+            err => CanvasGPUError::Validation(fmt_err(&err)),
+        }
+    }
+}
+
+impl From<wgpu_core::device::queue::QueueWriteError> for CanvasGPUError {
+    fn from(err: wgpu_core::device::queue::QueueWriteError) -> Self {
+        match err {
+            wgpu_core::device::queue::QueueWriteError::Queue(err) => err.into(),
+            err => CanvasGPUError::Validation(fmt_err(&err)),
+        }
+    }
+}
+
+impl From<wgpu_core::command::ClearError> for CanvasGPUError {
+    fn from(err: wgpu_core::command::ClearError) -> Self {
+        CanvasGPUError::Validation(fmt_err(&err))
+    }
+}
+
+impl From<wgpu_core::present::ConfigureSurfaceError> for CanvasGPUError {
+    fn from(err: wgpu_core::present::ConfigureSurfaceError) -> Self {
+        CanvasGPUError::Validation(fmt_err(&err))
+    }
+}
\ No newline at end of file
diff --git a/crates/canvas-c/src/webgpu/gpu.rs b/crates/canvas-c/src/webgpu/gpu.rs
index 1317f6a3d..2b6aeee07 100644
--- a/crates/canvas-c/src/webgpu/gpu.rs
+++ b/crates/canvas-c/src/webgpu/gpu.rs
@@ -1,7 +1,8 @@
-use crate::webgpu::gpu_supported_limits::CanvasGPUSupportedLimits;
+use std::{os::raw::c_void, sync::Arc};
+
+use wgpu_core::global::Global;
 
 use super::gpu_adapter::CanvasGPUAdapter;
-use std::{os::raw::c_void, sync::Arc};
 
 #[repr(C)]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -39,13 +40,27 @@ impl Default for CanvasGPURequestAdapterOptions {
     }
 }
 
+
 #[derive(Clone)]
-pub struct CanvasWebGPUInstance(pub(crate) Arc<wgpu_core::global::Global>);
+struct CanvasWebGPUInstanceInner {
+    pub(crate) global: Arc<Global>,
+}
+
+#[derive(Clone)]
+pub struct CanvasWebGPUInstance(CanvasWebGPUInstanceInner);
+
+impl CanvasWebGPUInstance {
+    pub(crate) fn global(&self) -> &Arc<Global> {
+        &self.0.global
+    }
+}
 
 unsafe impl Send for CanvasWebGPUInstance {}
+pub type WebGPUInstance = Arc<CanvasWebGPUInstance>;
+
 
 #[no_mangle]
-pub extern "C" fn canvas_native_webgpu_instance_create() -> *mut CanvasWebGPUInstance {
+pub extern "C" fn canvas_native_webgpu_instance_create() -> *const CanvasWebGPUInstance {
     #[cfg(not(target_os = "android"))]
     let backends = wgpu_types::Backends::METAL;
 
@@ -63,17 +78,22 @@ pub extern "C" fn canvas_native_webgpu_instance_create() -> *mut CanvasWebGPUIns
         },
     );
 
-    Box::into_raw(Box::new(CanvasWebGPUInstance(Arc::new(instance))))
+    let inner = CanvasWebGPUInstanceInner {
+        global: Arc::new(instance),
+    };
+
+    Arc::into_raw(Arc::new(CanvasWebGPUInstance(inner)))
 }
 
 #[no_mangle]
-pub extern "C" fn canvas_native_webgpu_instance_destroy(instance: *mut CanvasWebGPUInstance) {
+pub extern "C" fn canvas_native_webgpu_instance_release(instance: *const CanvasWebGPUInstance) {
     if instance.is_null() {
         return;
     }
-    let _ = unsafe { Box::from_raw(instance) };
+    let _ = unsafe { Arc::decrement_strong_count(instance) };
 }
 
+
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_request_adapter(
     instance: *const CanvasWebGPUInstance,
@@ -82,9 +102,7 @@ pub unsafe extern "C" fn canvas_native_webgpu_request_adapter(
     callback_data: *mut c_void,
 ) {
     use super::prelude::build_features;
-    
-
-    let instance = (&*instance).clone();
+    Arc::increment_strong_count(instance);
     let options = if options.is_null() {
         CanvasGPURequestAdapterOptions::default()
     } else {
@@ -99,6 +117,8 @@ pub unsafe extern "C" fn canvas_native_webgpu_request_adapter(
 
     let callback = callback as i64;
     let callback_data = callback_data as i64;
+    let instance = Arc::from_raw(instance);
+    let global = Arc::clone(instance.global());
     std::thread::spawn(move || {
         #[cfg(not(target_os = "android"))]
         let backends = wgpu_types::Backends::METAL;
@@ -108,10 +128,7 @@ pub unsafe extern "C" fn canvas_native_webgpu_request_adapter(
 
         #[cfg(target_os = "windows")]
         let backends = wgpu_types::Backends::DX12;
-
-        let instance = instance;
-
-        let global = &instance.0;
+        
 
         let adapter = global.request_adapter(
             &opts,
@@ -127,11 +144,11 @@ pub unsafe extern "C" fn canvas_native_webgpu_request_adapter(
                 gfx_select!(adapter_id => global.adapter_limits(adapter_id)).unwrap_or_default();
 
             let ret = CanvasGPUAdapter {
-                instance: instance.clone(),
+                instance,
                 adapter: adapter_id,
                 is_fallback_adapter: options.force_fallback_adapter,
-                features: features,
-                limits: limits,
+                features,
+                limits,
             };
 
             Box::into_raw(Box::new(ret))
diff --git a/crates/canvas-c/src/webgpu/gpu_adapter.rs b/crates/canvas-c/src/webgpu/gpu_adapter.rs
index 136aeb2e7..871b73fa3 100644
--- a/crates/canvas-c/src/webgpu/gpu_adapter.rs
+++ b/crates/canvas-c/src/webgpu/gpu_adapter.rs
@@ -1,10 +1,12 @@
 use std::{
     ffi::{CStr, CString},
-    os::raw::{c_char, c_void},
-    sync::Arc,
+    os::raw::{c_char, c_void}
+    ,
 };
+use std::sync::Arc;
 
 use crate::buffers::StringBuffer;
+use crate::webgpu::gpu_device::{DEFAULT_DEVICE_LOST_HANDLER, ErrorSinkRaw};
 
 use super::{
     gpu::CanvasWebGPUInstance, gpu_adapter_info::CanvasGPUAdapterInfo, gpu_device::CanvasGPUDevice,
@@ -12,7 +14,7 @@ use super::{
 };
 
 pub struct CanvasGPUAdapter {
-    pub(crate) instance: CanvasWebGPUInstance,
+    pub(crate) instance: Arc<CanvasWebGPUInstance>,
     pub(crate) adapter: wgpu_core::id::AdapterId,
     pub(crate) is_fallback_adapter: bool,
     pub(crate) features: Vec<&'static str>,
@@ -56,29 +58,29 @@ pub extern "C" fn canvas_native_webgpu_adapter_get_limits(
 #[no_mangle]
 pub extern "C" fn canvas_native_webgpu_request_adapter_info(
     adapter: *mut CanvasGPUAdapter,
-) -> *mut CanvasGPUAdapterInfo {
+) -> *const CanvasGPUAdapterInfo {
     if adapter.is_null() {
         return std::ptr::null_mut();
     }
     let adapter = unsafe { &mut *adapter };
 
     let adapter_id = adapter.adapter;
-    let global = &adapter.instance.0;
+    let global = adapter.instance.global();
 
-    gfx_select!(adapter_id => global.adapter_get_info(adapter.adapter))
-        .map(|info| Box::into_raw(Box::new(CanvasGPUAdapterInfo(info))))
+    gfx_select!(adapter_id => global.adapter_get_info(adapter_id))
+        .map(|info| Arc::into_raw(Arc::new(CanvasGPUAdapterInfo::new(info))))
         .ok()
-        .unwrap_or_else(|| std::ptr::null_mut())
+        .unwrap_or_else(|| std::ptr::null())
 }
 
 #[no_mangle]
 pub extern "C" fn canvas_native_webgpu_request_device(
-    adapter: *mut CanvasGPUAdapter,
+    adapter: *const CanvasGPUAdapter,
     label: *const c_char,
     required_features: *const *const c_char,
     required_features_length: usize,
     required_limits: *const CanvasGPUSupportedLimits,
-    callback: extern "C" fn(*mut c_char, *mut CanvasGPUDevice, *mut c_void),
+    callback: extern "C" fn(*mut c_char, *const CanvasGPUDevice, *mut c_void),
     callback_data: *mut c_void,
 ) {
     if adapter.is_null() {
@@ -86,7 +88,7 @@ pub extern "C" fn canvas_native_webgpu_request_device(
         return;
     }
 
-    let adapter = unsafe { &mut *adapter };
+    let adapter = unsafe { &*adapter };
     let features = parse_required_features(required_features, required_features_length);
 
     let mut limits = if required_limits.is_null() {
@@ -107,16 +109,15 @@ pub extern "C" fn canvas_native_webgpu_request_device(
     let instance = adapter.instance.clone();
     std::thread::spawn(move || {
         let descriptor = wgpu_types::DeviceDescriptor {
-            label: label,
+            label,
             required_features: features,
             required_limits: limits,
         };
-        
 
-        let instance_copy = instance.clone();
 
-    
-        let global = &instance.0;
+        let instance_copy = Arc::clone(&instance);
+
+        let global = instance.global();
 
         let (device, queue, error) = gfx_select!(adapter_id => global.adapter_request_device(
             adapter_id,
@@ -127,7 +128,7 @@ pub extern "C" fn canvas_native_webgpu_request_device(
         ));
 
         let callback = unsafe {
-            std::mem::transmute::<*const i64, fn(*mut c_char, *mut CanvasGPUDevice, *mut c_void)>(
+            std::mem::transmute::<*const i64, fn(*mut c_char, *const CanvasGPUDevice, *mut c_void)>(
                 callback as _,
             )
         };
@@ -138,14 +139,25 @@ pub extern "C" fn canvas_native_webgpu_request_device(
             let ret = CString::new(error).unwrap().into_raw();
             callback(ret, std::ptr::null_mut(), callback_data);
         } else {
-            let queue = CanvasGPUQueue {
-                instance: instance_copy.clone(),
-                queue,
-            };
-            let ret = Box::into_raw(Box::new(CanvasGPUDevice {
+            let error_sink = Arc::new(parking_lot::Mutex::new(
+                ErrorSinkRaw::new(DEFAULT_DEVICE_LOST_HANDLER)
+            ));
+
+            let queue = Arc::new(
+                CanvasGPUQueue {
+                    instance: instance_copy.clone(),
+                    queue,
+                    error_sink: error_sink.clone(),
+                }
+            );
+
+
+            let ret = Arc::into_raw(Arc::new(CanvasGPUDevice {
                 device,
                 queue,
+                user_data: std::ptr::null_mut(),
                 instance: instance_copy,
+                error_sink,
             }));
             callback(std::ptr::null_mut(), ret, callback_data);
         }
diff --git a/crates/canvas-c/src/webgpu/gpu_adapter_info.rs b/crates/canvas-c/src/webgpu/gpu_adapter_info.rs
index 12d4bdac4..38adddf69 100644
--- a/crates/canvas-c/src/webgpu/gpu_adapter_info.rs
+++ b/crates/canvas-c/src/webgpu/gpu_adapter_info.rs
@@ -1,6 +1,13 @@
 use std::{ffi::CString, os::raw::c_char};
+use std::sync::Arc;
 
-pub struct CanvasGPUAdapterInfo(pub(crate) wgpu_types::AdapterInfo);
+pub struct CanvasGPUAdapterInfo(wgpu_types::AdapterInfo);
+
+impl CanvasGPUAdapterInfo {
+    pub fn new(types: wgpu_types::AdapterInfo) -> Self {
+        Self(types)
+    }
+}
 
 #[no_mangle]
 pub extern "C" fn canvas_native_webgpu_adapter_info_vendor(
@@ -15,7 +22,7 @@ pub extern "C" fn canvas_native_webgpu_adapter_info_vendor(
 
 #[no_mangle]
 pub extern "C" fn canvas_native_webgpu_adapter_info_architecture(
-    info: *const CanvasGPUAdapterInfo,
+    _info: *const CanvasGPUAdapterInfo,
 ) -> *mut c_char {
     // if info.is_null() {return std::ptr::null()}
     // let info = unsafe {&*info};
@@ -47,12 +54,24 @@ pub extern "C" fn canvas_native_webgpu_adapter_info_description(
 
 
 #[no_mangle]
-pub unsafe extern "C" fn canvas_native_webgpu_adapter_info_destroy(
-    info: *mut CanvasGPUAdapterInfo,
+pub unsafe extern "C" fn canvas_native_webgpu_adapter_info_reference(
+    info: *const CanvasGPUAdapterInfo,
+) {
+    if info.is_null() {
+        return;
+    }
+
+    Arc::increment_strong_count(info);
+}
+
+
+#[no_mangle]
+pub unsafe extern "C" fn canvas_native_webgpu_adapter_info_release(
+    info: *const CanvasGPUAdapterInfo,
 ) {
     if info.is_null() {
         return;
     }
-   
-    let _ = Box::from_raw(info);
+
+    Arc::decrement_strong_count(info);
 }
diff --git a/crates/canvas-c/src/webgpu/gpu_bind_group.rs b/crates/canvas-c/src/webgpu/gpu_bind_group.rs
index 4f0f448b4..a1d1ac6b9 100644
--- a/crates/canvas-c/src/webgpu/gpu_bind_group.rs
+++ b/crates/canvas-c/src/webgpu/gpu_bind_group.rs
@@ -1,6 +1,42 @@
+use std::borrow::Cow;
+use std::sync::Arc;
+use crate::webgpu::gpu_bind_group_layout::CanvasGPUBindGroupLayout;
 use super::gpu::CanvasWebGPUInstance;
 
 pub struct CanvasGPUBindGroup {
-    pub(crate) instance: CanvasWebGPUInstance,
+    pub(crate) label: Option<Cow<'static, str>>,
+    pub(crate) instance: Arc<CanvasWebGPUInstance>,
     pub(crate) group: wgpu_core::id::BindGroupId,
 }
+
+
+impl Drop for CanvasGPUBindGroup {
+    fn drop(&mut self) {
+        let global = self.instance.global();
+        let group_id = self.group;
+        gfx_select!(group_id => global.bind_group_drop(group_id));
+    }
+}
+
+
+#[no_mangle]
+pub unsafe extern "C" fn canvas_native_webgpu_bind_group_reference(
+    bind_group: *const CanvasGPUBindGroup,
+) {
+    if bind_group.is_null() {
+        return;
+    }
+
+    Arc::increment_strong_count(bind_group);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn canvas_native_webgpu_bind_group_release(
+    bind_group: *const CanvasGPUBindGroup,
+) {
+    if bind_group.is_null() {
+        return;
+    }
+
+    Arc::decrement_strong_count(bind_group);
+}
\ No newline at end of file
diff --git a/crates/canvas-c/src/webgpu/gpu_bind_group_layout.rs b/crates/canvas-c/src/webgpu/gpu_bind_group_layout.rs
index dd486db23..de0911122 100644
--- a/crates/canvas-c/src/webgpu/gpu_bind_group_layout.rs
+++ b/crates/canvas-c/src/webgpu/gpu_bind_group_layout.rs
@@ -1,6 +1,38 @@
+use std::sync::Arc;
+
 use super::gpu::CanvasWebGPUInstance;
 
 pub struct CanvasGPUBindGroupLayout {
-    pub(crate) instance: CanvasWebGPUInstance,
+    pub(crate) instance: Arc<CanvasWebGPUInstance>,
     pub(crate) group_layout: wgpu_core::id::BindGroupLayoutId,
 }
+
+impl Drop for CanvasGPUBindGroupLayout {
+    fn drop(&mut self) {
+        let global = self.instance.global();
+        let group_layout_id = self.group_layout;
+        gfx_select!(group_id => global.bind_group_layout_drop(group_layout_id));
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn canvas_native_webgpu_bind_group_layout_reference(
+    bind_group_layout: *const CanvasGPUBindGroupLayout,
+) {
+    if bind_group_layout.is_null() {
+        return;
+    }
+
+    Arc::increment_strong_count(bind_group_layout);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn canvas_native_webgpu_bind_group_layout_release(
+    bind_group_layout: *const CanvasGPUBindGroupLayout,
+) {
+    if bind_group_layout.is_null() {
+        return;
+    }
+
+    Arc::decrement_strong_count(bind_group_layout);
+}
\ No newline at end of file
diff --git a/crates/canvas-c/src/webgpu/gpu_buffer.rs b/crates/canvas-c/src/webgpu/gpu_buffer.rs
index 3c8407999..b57e5b111 100644
--- a/crates/canvas-c/src/webgpu/gpu_buffer.rs
+++ b/crates/canvas-c/src/webgpu/gpu_buffer.rs
@@ -3,8 +3,9 @@ use std::{
     ffi::CString,
     os::raw::{c_char, c_void},
 };
+use std::sync::Arc;
 
-use crate::buffers::U8Buffer;
+use crate::webgpu::error::{CanvasGPUError, CanvasGPUErrorType, handle_error_fatal};
 
 use super::gpu::CanvasWebGPUInstance;
 
@@ -34,11 +35,12 @@ impl From<wgpu_core::device::HostMap> for GPUMapMode {
 }
 
 pub struct CanvasGPUBuffer {
-    pub(crate) instance: CanvasWebGPUInstance,
+    pub(crate) instance: Arc<CanvasWebGPUInstance>,
     pub(crate) label: Cow<'static, str>,
     pub(crate) buffer: wgpu_core::id::BufferId,
     pub(crate) size: u64,
     pub(crate) usage: u32,
+    pub(crate) error_sink: super::gpu_device::ErrorSink,
 }
 
 impl CanvasGPUBuffer {
@@ -52,13 +54,13 @@ impl CanvasGPUBuffer {
 
     pub fn destroy(&self) {
         let buffer_id = self.buffer;
-        let global = &self.instance.0;
-        gfx_select!(buffer_id => global.buffer_destroy(buffer_id));
+        let global = self.instance.global();
+        let _ = gfx_select!(buffer_id => global.buffer_destroy(buffer_id));
     }
 
     pub fn unmap(&self) {
         let buffer_id = self.buffer;
-        let global = &self.instance.0;
+        let global = self.instance.global();
         gfx_select!(buffer_id => global.buffer_unmap(buffer_id));
     }
 }
@@ -88,16 +90,16 @@ pub unsafe extern "C" fn canvas_native_webgpu_buffer_get_mapped_range(
     size: i64,
     dst: *mut u8,
     dst_size: usize,
-) -> *mut c_char {
+) {
     if buffer.is_null() {
-        return std::ptr::null_mut();
+        return;
     }
     let buffer = unsafe { &*buffer };
     let offset: u64 = offset.try_into().ok().unwrap_or_default();
     let size: Option<u64> = size.try_into().ok();
 
     let buffer_id = buffer.buffer;
-    let global = &buffer.instance.0;
+    let global = buffer.instance.global();
 
     let range = gfx_select!( buffer_id => global.buffer_get_mapped_range(buffer_id, offset, size));
 
@@ -106,11 +108,9 @@ pub unsafe extern "C" fn canvas_native_webgpu_buffer_get_mapped_range(
             let src = std::slice::from_raw_parts(buf, len as usize);
             let dst = std::slice::from_raw_parts_mut(dst, dst_size);
             dst.copy_from_slice(src);
-            std::ptr::null_mut()
         }
         Err(err) => {
-            let err = err.to_string();
-            CString::new(err).unwrap().into_raw()
+            handle_error_fatal(global, err, "canvas_native_webgpu_buffer_get_mapped_range")
         }
     }
 }
@@ -157,21 +157,49 @@ pub extern "C" fn canvas_native_webgpu_buffer_map_async(
         callback: Some(wgpu_core::resource::BufferMapCallback::from_rust(Box::new(
             move |result| {
                 let callback = unsafe {
-                    std::mem::transmute::<*const i64, fn(*mut c_char, *mut c_void)>(callback as _)
+                    std::mem::transmute::<*const i64, fn(CanvasGPUErrorType, *mut c_char, *mut c_void)>(callback as _)
                 };
                 let callback_data = callback_data as *mut c_void;
                 if let Err(error) = result {
-                    let error = error.to_string();
-                    let error = CString::new(error).unwrap().into_raw();
-                    callback(error, callback_data);
+                    let error: CanvasGPUError = error.into();
+                    let (typ, msg) = match error {
+                        CanvasGPUError::None => (
+                            CanvasGPUErrorType::None,
+                            None
+                        ),
+                        CanvasGPUError::Lost => {
+                            (
+                                CanvasGPUErrorType::Lost,
+                                None
+                            )
+                        }
+                        CanvasGPUError::OutOfMemory => (
+                            CanvasGPUErrorType::OutOfMemory,
+                            None
+                        ),
+                        CanvasGPUError::Validation(value) => (
+                            CanvasGPUErrorType::Validation,
+                            Some(CString::new(value).unwrap())
+                        ),
+                        CanvasGPUError::Internal => (
+                            CanvasGPUErrorType::Internal,
+                            None
+                        ),
+                    };
+
+                    let msg = msg
+                        .map(|value| value.into_raw())
+                        .unwrap_or(std::ptr::null_mut());
+
+                    callback(typ, msg, callback_data);
                 } else {
-                    callback(std::ptr::null_mut(), callback_data);
+                    callback(CanvasGPUErrorType::None, std::ptr::null_mut(), callback_data);
                 }
             },
         ))),
     };
 
-    let global = &buffer.instance.0;
+    let global = buffer.instance.global();
     let buffer_id = buffer.buffer;
 
     gfx_select!(buffer_id => global.buffer_map_async(buffer_id, offset, size, op));
diff --git a/crates/canvas-c/src/webgpu/gpu_canvas_context.rs b/crates/canvas-c/src/webgpu/gpu_canvas_context.rs
index 7ea4698be..0760e35b0 100644
--- a/crates/canvas-c/src/webgpu/gpu_canvas_context.rs
+++ b/crates/canvas-c/src/webgpu/gpu_canvas_context.rs
@@ -1,19 +1,29 @@
 use std::os::raw::c_void;
+use std::sync::Arc;
+
+use raw_window_handle::{
+    AppKitDisplayHandle, HasRawWindowHandle, RawDisplayHandle, RawWindowHandle,
+};
+
+use crate::webgpu::error::handle_error_fatal;
+use crate::webgpu::gpu_adapter::CanvasGPUAdapter;
+use crate::webgpu::gpu_device::{ErrorSink, ErrorSinkRaw, DEFAULT_DEVICE_LOST_HANDLER};
 
 use super::{
     enums::CanvasGPUTextureFormat, gpu::CanvasWebGPUInstance, gpu_device::CanvasGPUDevice,
     gpu_texture::CanvasGPUTexture,
 };
-use raw_window_handle::{
-    AppKitDisplayHandle, HasRawWindowHandle, RawDisplayHandle, RawWindowHandle,
-};
+
 pub struct CanvasGPUCanvasContext {
-    pub(crate) instance: CanvasWebGPUInstance,
+    pub(crate) instance: Arc<CanvasWebGPUInstance>,
     pub(crate) surface: wgpu_core::id::SurfaceId,
     pub(crate) width: u32,
     pub(crate) height: u32,
     pub(crate) format: wgpu_types::TextureFormat,
     pub(crate) usage: u32,
+    pub(crate) device: Option<wgpu_core::id::DeviceId>,
+    pub(crate) has_surface_presented: Arc<std::sync::atomic::AtomicBool>,
+    pub(crate) error_sink: ErrorSink,
 }
 
 #[cfg(any(target_os = "android"))]
@@ -23,36 +33,41 @@ pub unsafe extern "C" fn canvas_native_webgpu_context_create(
     window: *mut c_void,
     width: u32,
     height: u32,
-) -> *mut CanvasGPUCanvasContext {
+) -> *const CanvasGPUCanvasContext {
     if instance.is_null() {
         return std::ptr::null_mut();
     }
-    let instance = unsafe { &*instance };
-    let global = &instance.0;
 
-    let display_handle = raw_window_handle::RawDisplayHandle::Android(
-        raw_window_handle::AndroidDisplayHandle::new(),
-    );
+    Arc::increment_strong_count(instance);
+    let instance = Arc::from_raw(instance);
+    let global = instance.global();
 
-    let mut handle =
+    let display_handle = RawDisplayHandle::Android(raw_window_handle::AndroidDisplayHandle::new());
+
+    let handle =
         raw_window_handle::AndroidNdkWindowHandle::new(std::ptr::NonNull::new_unchecked(window));
-    let window_handle = raw_window_handle::RawWindowHandle::AndroidNdk(handle);
+    let window_handle = RawWindowHandle::AndroidNdk(handle);
 
     match global.instance_create_surface(display_handle, window_handle, None) {
         Ok(surface_id) => {
             let ctx = CanvasGPUCanvasContext {
-                instance: instance.clone(),
+                instance,
                 surface: surface_id,
                 width,
                 height,
                 format: wgpu_types::TextureFormat::Rgba8Unorm,
                 usage: wgpu_types::TextureUsages::RENDER_ATTACHMENT.bits(),
+                device: None,
+                has_surface_presented: Arc::default(),
+                error_sink: Arc::new(parking_lot::Mutex::new(ErrorSinkRaw::new(
+                    DEFAULT_DEVICE_LOST_HANDLER,
+                ))),
             };
 
-            Box::into_raw(Box::new(ctx))
+            Arc::into_raw(Arc::new(ctx))
         }
-        Err(err) => {
-            // todo handle error
+        Err(cause) => {
+            handle_error_fatal(global, cause, "canvas_native_webgpu_context_create");
             std::ptr::null_mut()
         }
     }
@@ -61,33 +76,39 @@ pub unsafe extern "C" fn canvas_native_webgpu_context_create(
 #[cfg(any(target_os = "ios", target_os = "macos"))]
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_context_create(
-    instance: *mut CanvasWebGPUInstance,
+    instance: *const CanvasWebGPUInstance,
     view: *mut c_void,
     width: u32,
     height: u32,
-) -> *mut CanvasGPUCanvasContext {
+) -> *const CanvasGPUCanvasContext {
     if instance.is_null() {
-        return std::ptr::null_mut();
+        return std::ptr::null();
     }
-    let instance = unsafe { &*instance };
-    let global = &instance.0;
+    Arc::increment_strong_count(instance);
+    let instance = Arc::from_raw(instance);
+    let global = instance.global();
 
     match global.instance_create_surface_metal(view, None) {
         Ok(surface_id) => {
             let ctx = CanvasGPUCanvasContext {
-                instance: instance.clone(),
+                instance,
                 surface: surface_id,
                 width,
                 height,
                 format: wgpu_types::TextureFormat::Bgra8Unorm,
                 usage: wgpu_types::TextureUsages::RENDER_ATTACHMENT.bits(),
+                device: None,
+                has_surface_presented: Arc::default(),
+                error_sink: Arc::new(parking_lot::Mutex::new(ErrorSinkRaw::new(
+                    DEFAULT_DEVICE_LOST_HANDLER,
+                ))),
             };
 
-            Box::into_raw(Box::new(ctx))
+            Arc::into_raw(Arc::new(ctx))
         }
-        Err(err) => {
-            // todo handle error
-            std::ptr::null_mut()
+        Err(cause) => {
+            handle_error_fatal(global, cause, "canvas_native_webgpu_context_create");
+            std::ptr::null()
         }
     }
 }
@@ -95,40 +116,44 @@ pub unsafe extern "C" fn canvas_native_webgpu_context_create(
 #[cfg(any(target_os = "ios"))]
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_context_create_uiview(
-    instance: *mut CanvasWebGPUInstance,
+    instance: *const CanvasWebGPUInstance,
     view: *mut c_void,
     width: u32,
     height: u32,
-) -> *mut CanvasGPUCanvasContext {
+) -> *const CanvasGPUCanvasContext {
     if instance.is_null() {
-        return std::ptr::null_mut();
+        return std::ptr::null();
     }
-    let instance = unsafe { &*instance };
-    let global = &instance.0;
+    Arc::increment_strong_count(instance);
+    let instance = Arc::from_raw(instance);
+    let global = instance.global();
 
-    let display_handle =
-        raw_window_handle::RawDisplayHandle::UiKit(raw_window_handle::UiKitDisplayHandle::new());
+    let display_handle = RawDisplayHandle::UiKit(raw_window_handle::UiKitDisplayHandle::new());
 
-    let mut handle =
-        raw_window_handle::UiKitWindowHandle::new(std::ptr::NonNull::new_unchecked(view));
-    let window_handle = raw_window_handle::RawWindowHandle::UiKit(handle);
+    let handle = raw_window_handle::UiKitWindowHandle::new(std::ptr::NonNull::new_unchecked(view));
+    let window_handle = RawWindowHandle::UiKit(handle);
 
     match global.instance_create_surface(display_handle, window_handle, None) {
         Ok(surface_id) => {
             let ctx = CanvasGPUCanvasContext {
-                instance: instance.clone(),
+                instance,
                 surface: surface_id,
                 width,
                 height,
                 format: wgpu_types::TextureFormat::Bgra8Unorm,
                 usage: wgpu_types::TextureUsages::RENDER_ATTACHMENT.bits(),
+                device: None,
+                has_surface_presented: Arc::default(),
+                error_sink: Arc::new(parking_lot::Mutex::new(ErrorSinkRaw::new(
+                    DEFAULT_DEVICE_LOST_HANDLER,
+                ))),
             };
 
-            Box::into_raw(Box::new(ctx))
+            Arc::into_raw(Arc::new(ctx))
         }
-        Err(err) => {
-            // todo handle error
-            std::ptr::null_mut()
+        Err(cause) => {
+            handle_error_fatal(global, cause, "canvas_native_webgpu_context_create_uiview");
+            std::ptr::null()
         }
     }
 }
@@ -136,39 +161,44 @@ pub unsafe extern "C" fn canvas_native_webgpu_context_create_uiview(
 #[cfg(any(target_os = "macos"))]
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_context_create_nsview(
-    instance: *mut CanvasWebGPUInstance,
+    instance: *const CanvasWebGPUInstance,
     view: *mut c_void,
     width: u32,
     height: u32,
-) -> *mut CanvasGPUCanvasContext {
+) -> *const CanvasGPUCanvasContext {
     if instance.is_null() {
-        return std::ptr::null_mut();
+        return std::ptr::null();
     }
-    let instance = unsafe { &*instance };
-    let global = &instance.0;
+    Arc::increment_strong_count(instance);
+    let instance = Arc::from_raw(instance);
+    let global = instance.global();
 
-    let display_handle =
-        raw_window_handle::RawDisplayHandle::AppKit(raw_window_handle::AppKitDisplayHandle::new());
+    let display_handle = RawDisplayHandle::AppKit(AppKitDisplayHandle::new());
 
     let handle = raw_window_handle::AppKitWindowHandle::new(std::ptr::NonNull::new_unchecked(view));
-    let window_handle = raw_window_handle::RawWindowHandle::AppKit(handle);
+    let window_handle = RawWindowHandle::AppKit(handle);
 
     match global.instance_create_surface(display_handle, window_handle, None) {
         Ok(surface_id) => {
             let ctx = CanvasGPUCanvasContext {
-                instance: instance.clone(),
+                instance,
                 surface: surface_id,
                 width,
                 height,
                 format: wgpu_types::TextureFormat::Bgra8Unorm,
                 usage: wgpu_types::TextureUsages::RENDER_ATTACHMENT.bits(),
+                device: None,
+                has_surface_presented: Arc::default(),
+                error_sink: Arc::new(parking_lot::Mutex::new(ErrorSinkRaw::new(
+                    DEFAULT_DEVICE_LOST_HANDLER,
+                ))),
             };
 
-            Box::into_raw(Box::new(ctx))
+            Arc::into_raw(Arc::new(ctx))
         }
-        Err(err) => {
-            // todo handle error
-            std::ptr::null_mut()
+        Err(cause) => {
+            handle_error_fatal(global, cause, "canvas_native_webgpu_context_create");
+            std::ptr::null()
         }
     }
 }
@@ -259,17 +289,18 @@ pub struct CanvasGPUSurfaceConfiguration {
 }
 
 #[no_mangle]
-pub extern "C" fn canvas_native_webgpu_context_configure(
-    context: *mut CanvasGPUCanvasContext,
-    device: *mut CanvasGPUDevice,
+pub unsafe extern "C" fn canvas_native_webgpu_context_configure(
+    context: *const CanvasGPUCanvasContext,
+    device: *const CanvasGPUDevice,
     config: *const CanvasGPUSurfaceConfiguration,
 ) {
     if context.is_null() || device.is_null() {
         return;
     }
-    let context = unsafe { &*context };
+    Arc::increment_strong_count(context);
+    let mut context = Arc::from_raw(context);
     let surface_id = context.surface;
-    let global = &context.instance.0;
+    let global = context.instance.global();
     let device = unsafe { &*device };
     let device_id = device.device;
 
@@ -295,18 +326,30 @@ pub extern "C" fn canvas_native_webgpu_context_configure(
         height: context.width,
         present_mode: config.presentMode.into(),
         alpha_mode: config.alphaMode.into(),
-        view_formats: view_formats,
+        view_formats,
     };
 
-    // todo handle error
-    if let Some(err) =
+    if let Some(cause) =
         gfx_select!(surface_id => global.surface_configure(surface_id, device_id, &config))
-    {}
+    {
+        handle_error_fatal(global, cause, "canvas_native_webgpu_context_configure");
+
+        if let Some(context) = Arc::get_mut(&mut context) {
+            context.device = None;
+        }
+    } else {
+        if let Some(context) = Arc::get_mut(&mut context) {
+            context.device = Some(device_id);
+            context
+                .has_surface_presented
+                .store(false, std::sync::atomic::Ordering::SeqCst);
+        }
+    }
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_context_unconfigure(
-    context: *mut CanvasGPUCanvasContext,
+    context: *const CanvasGPUCanvasContext,
     device: *mut CanvasGPUDevice,
     config: *const CanvasGPUSurfaceConfiguration,
 ) {
@@ -315,7 +358,7 @@ pub unsafe extern "C" fn canvas_native_webgpu_context_unconfigure(
     }
     let context = &*context;
     let surface_id = context.surface;
-    let global = &context.instance.0;
+    let global = context.instance.global();
     let device = &*device;
     let device_id = device.device;
     let config = &*config;
@@ -323,14 +366,23 @@ pub unsafe extern "C" fn canvas_native_webgpu_context_unconfigure(
 
 #[no_mangle]
 pub extern "C" fn canvas_native_webgpu_context_get_current_texture(
-    context: *mut CanvasGPUCanvasContext,
-) -> *mut CanvasGPUTexture {
+    context: *const CanvasGPUCanvasContext,
+) -> *const CanvasGPUTexture {
     if context.is_null() {
-        return std::ptr::null_mut();
+        return std::ptr::null();
     }
 
     let context = unsafe { &*context };
-    let global = &context.instance.0;
+    let global = context.instance.global();
+
+    if context.device.is_none() {
+        handle_error_fatal(
+            global,
+            wgpu_core::present::SurfaceError::NotConfigured,
+            "canvas_native_webgpu_context_get_current_texture",
+        );
+        return std::ptr::null();
+    }
 
     let surface_id = context.surface;
 
@@ -339,7 +391,7 @@ pub extern "C" fn canvas_native_webgpu_context_get_current_texture(
     match result {
         Ok(texture) => match texture.status {
             wgpu_types::SurfaceStatus::Good | wgpu_types::SurfaceStatus::Suboptimal => {
-                Box::into_raw(Box::new(CanvasGPUTexture {
+                Arc::into_raw(Arc::new(CanvasGPUTexture {
                     instance: context.instance.clone(),
                     texture: texture.texture_id.unwrap(),
                     owned: false,
@@ -351,14 +403,69 @@ pub extern "C" fn canvas_native_webgpu_context_get_current_texture(
                     width: context.width,
                     height: context.height,
                     usage: context.usage,
+                    error_sink: context.error_sink.clone(),
                 }))
             }
             _ => std::ptr::null_mut(),
         },
-        Err(error) => {
-            println!("error: {:?}", error.to_string());
-            // todo handle error
+        Err(cause) => {
+            handle_error_fatal(
+                global,
+                cause,
+                "canvas_native_webgpu_context_get_current_texture",
+            );
             std::ptr::null_mut()
         }
     }
 }
+
+#[no_mangle]
+pub extern "C" fn canvas_native_webgpu_context_present_surface(
+    context: *const CanvasGPUCanvasContext,
+) {
+    if context.is_null() {
+        return;
+    }
+
+    let context = unsafe { &*context };
+    let global = context.instance.global();
+
+    let surface_id = context.surface;
+
+    if let Some(_) = context.device {
+        if let Err(cause) = gfx_select!(device => global.surface_present(surface_id)) {
+            handle_error_fatal(
+                global,
+                cause,
+                "canvas_native_webgpu_context_present_surface",
+            )
+        } else {
+            context
+                .has_surface_presented
+                .store(false, std::sync::atomic::Ordering::SeqCst);
+        }
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn canvas_native_webgpu_context_get_capabilities(
+    context: *const CanvasGPUCanvasContext,
+    adapter: *const CanvasGPUAdapter,
+) {
+    if context.is_null() || adapter.is_null() {
+        return;
+    }
+
+    let adapter = unsafe { &*adapter };
+    let adapter_id = adapter.adapter;
+    let context = unsafe { &*context };
+    let global = context.instance.global();
+
+    let surface_id = context.surface;
+
+    if let Ok(capabilities) =
+        gfx_select!(surface_id => global.surface_get_capabilities(surface_id, adapter_id))
+    {
+        log::debug!(target: "JS", "canvas_native_webgpu_context_get_capabilities : {:?}", capabilities);
+    }
+}
diff --git a/crates/canvas-c/src/webgpu/gpu_command_buffer.rs b/crates/canvas-c/src/webgpu/gpu_command_buffer.rs
index 832f847c2..f176eaedc 100644
--- a/crates/canvas-c/src/webgpu/gpu_command_buffer.rs
+++ b/crates/canvas-c/src/webgpu/gpu_command_buffer.rs
@@ -1,6 +1,7 @@
+use std::sync::Arc;
 use super::gpu::CanvasWebGPUInstance;
 
 pub struct CanvasGPUCommandBuffer {
-    pub(crate) instance: CanvasWebGPUInstance,
+    pub(crate) instance: Arc<CanvasWebGPUInstance>,
     pub(crate) command_buffer: wgpu_core::id::CommandBufferId,
 }
diff --git a/crates/canvas-c/src/webgpu/gpu_command_encoder.rs b/crates/canvas-c/src/webgpu/gpu_command_encoder.rs
index dd4c90265..e991f9cf3 100644
--- a/crates/canvas-c/src/webgpu/gpu_command_encoder.rs
+++ b/crates/canvas-c/src/webgpu/gpu_command_encoder.rs
@@ -1,13 +1,17 @@
 use std::{ffi::CStr, os::raw::c_char};
+use std::sync::Arc;
+
+use crate::webgpu::error::handle_error;
+use crate::webgpu::prelude::ptr_into_label;
 
 use super::{
     enums::CanvasTextureAspect,
     gpu::CanvasWebGPUInstance,
     gpu_buffer::CanvasGPUBuffer,
     gpu_command_buffer::CanvasGPUCommandBuffer,
-    gpu_compute_pass::CanvasGPUComputePass,
+    gpu_compute_pass_encoder::CanvasGPUComputePassEncoder,
     gpu_query_set::CanvasGPUQuerySet,
-    gpu_render_pass::CanvasGPURenderPass,
+    gpu_render_pass_encoder::CanvasGPURenderPassEncoder,
     gpu_texture::CanvasGPUTexture,
     structs::{
         CanvasExtent3d, CanvasOrigin3d, CanvasRenderPassColorAttachment,
@@ -16,8 +20,31 @@ use super::{
 };
 
 pub struct CanvasGPUCommandEncoder {
-    pub(crate) instance: CanvasWebGPUInstance,
+    pub(crate) instance: Arc<CanvasWebGPUInstance>,
     pub(crate) encoder: wgpu_core::id::CommandEncoderId,
+    pub(crate) error_sink: super::gpu_device::ErrorSink,
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn canvas_native_webgpu_command_encoder_reference(
+    command_encoder: *const CanvasGPUCommandEncoder
+) {
+    if command_encoder.is_null() {
+        return;
+    }
+
+    Arc::increment_strong_count(command_encoder);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn canvas_native_webgpu_command_encoder_release(
+    command_encoder: *const CanvasGPUCommandEncoder
+) {
+    if command_encoder.is_null() {
+        return;
+    }
+
+    Arc::decrement_strong_count(command_encoder);
 }
 
 #[repr(C)]
@@ -38,20 +65,16 @@ pub struct CanvasImageCopyTexture {
 
 #[no_mangle]
 pub extern "C" fn canvas_native_webgpu_command_encoder_begin_compute_pass(
-    command_encoder: *mut CanvasGPUCommandEncoder,
+    command_encoder: *const CanvasGPUCommandEncoder,
     query_set: *const CanvasGPUQuerySet,
     label: *const c_char,
     beginning_of_pass_write_index: i32,
     end_of_pass_write_index: i32,
-) -> *mut CanvasGPUComputePass {
+) -> *const CanvasGPUComputePassEncoder {
     if command_encoder.is_null() {
         return std::ptr::null_mut();
     }
-    let label = if !label.is_null() {
-        Some(unsafe { CStr::from_ptr(label).to_string_lossy() })
-    } else {
-        None
-    };
+    let label = ptr_into_label(label);
 
     let timestamp_writes = if !query_set.is_null() {
         let query_set = unsafe { &*query_set };
@@ -62,32 +85,34 @@ pub extern "C" fn canvas_native_webgpu_command_encoder_begin_compute_pass(
 
         Some(wgpu_core::command::ComputePassTimestampWrites {
             query_set: query_set.query,
-            beginning_of_pass_write_index: beginning_of_pass_write_index,
-            end_of_pass_write_index: end_of_pass_write_index,
+            beginning_of_pass_write_index,
+            end_of_pass_write_index,
         })
     } else {
         None
     };
 
-    let command_encoder = unsafe { &mut *command_encoder };
+    let command_encoder = unsafe { &*command_encoder };
 
     let desc = wgpu_core::command::ComputePassDescriptor {
-        label: label,
+        label: label.clone(),
         timestamp_writes: timestamp_writes.as_ref(),
     };
 
     let pass = wgpu_core::command::ComputePass::new(command_encoder.encoder, &desc);
 
-    let pass_encoder = CanvasGPUComputePass {
+    let pass_encoder = CanvasGPUComputePassEncoder {
+        label,
         instance: command_encoder.instance.clone(),
-        pass,
+        pass: Box::into_raw(Box::new(pass)),
+        error_sink: command_encoder.error_sink.clone(),
     };
-    Box::into_raw(Box::new(pass_encoder))
+    Arc::into_raw(Arc::new(pass_encoder))
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_command_encoder_begin_render_pass(
-    command_encoder: *mut CanvasGPUCommandEncoder,
+    command_encoder: *const CanvasGPUCommandEncoder,
     label: *const c_char,
     color_attachments: *const CanvasRenderPassColorAttachment,
     color_attachments_size: usize,
@@ -96,15 +121,11 @@ pub unsafe extern "C" fn canvas_native_webgpu_command_encoder_begin_render_pass(
     query_set: *const CanvasGPUQuerySet,
     beginning_of_pass_write_index: i32,
     end_of_pass_write_index: i32,
-) -> *mut CanvasGPURenderPass {
+) -> *const CanvasGPURenderPassEncoder {
     if command_encoder.is_null() {
         return std::ptr::null_mut();
     }
-    let label = if !label.is_null() {
-        Some(unsafe { CStr::from_ptr(label).to_string_lossy() })
-    } else {
-        None
-    };
+    let label = ptr_into_label(label);
 
     let color_attachments = if !color_attachments.is_null() && color_attachments_size > 0 {
         let color_attachments =
@@ -122,7 +143,7 @@ pub unsafe extern "C" fn canvas_native_webgpu_command_encoder_begin_render_pass(
                 let view = unsafe { &*value.view };
                 Some(wgpu_core::command::RenderPassColorAttachment {
                     view: view.texture_view,
-                    resolve_target: resolve_target,
+                    resolve_target,
                     channel: wgpu_core::command::PassChannel {
                         load_op: value.channel.load_op.into(),
                         store_op: value.channel.store_op.into(),
@@ -136,7 +157,6 @@ pub unsafe extern "C" fn canvas_native_webgpu_command_encoder_begin_render_pass(
         vec![]
     };
 
-
     let timestamp_writes = if !query_set.is_null() {
         let query_set = unsafe { &*query_set };
         let beginning_of_pass_write_index = if beginning_of_pass_write_index < 0 {
@@ -154,14 +174,14 @@ pub unsafe extern "C" fn canvas_native_webgpu_command_encoder_begin_render_pass(
         let query_set_id = query_set.query;
         Some(wgpu_core::command::RenderPassTimestampWrites {
             query_set: query_set_id,
-            beginning_of_pass_write_index: beginning_of_pass_write_index,
-            end_of_pass_write_index: end_of_pass_write_index,
+            beginning_of_pass_write_index,
+            end_of_pass_write_index,
         })
     } else {
         None
     };
 
-    let command_encoder = unsafe { &mut *command_encoder };
+    let command_encoder = unsafe { &*command_encoder };
     let command_encoder_id = command_encoder.encoder;
 
     let depth_stencil_attachment = if !depth_stencil_attachment.is_null() {
@@ -181,8 +201,8 @@ pub unsafe extern "C" fn canvas_native_webgpu_command_encoder_begin_render_pass(
         };
         Some(wgpu_core::command::RenderPassDepthStencilAttachment {
             view: view.texture_view,
-            depth: depth,
-            stencil: stencil,
+            depth,
+            stencil,
         })
     } else {
         None
@@ -196,24 +216,26 @@ pub unsafe extern "C" fn canvas_native_webgpu_command_encoder_begin_render_pass(
     };
 
     let desc = wgpu_core::command::RenderPassDescriptor {
-        label,
+        label: label.clone(),
         color_attachments: std::borrow::Cow::Owned(color_attachments),
         depth_stencil_attachment: depth_stencil_attachment.as_ref(),
         timestamp_writes: timestamp_writes.as_ref(),
-        occlusion_query_set: occlusion_query_set,
+        occlusion_query_set,
     };
     let pass = wgpu_core::command::RenderPass::new(command_encoder_id, &desc);
-    
-    let pass_encoder = CanvasGPURenderPass {
+
+    let pass_encoder = CanvasGPURenderPassEncoder {
+        label,
         instance: command_encoder.instance.clone(),
-        pass,
+        pass: Box::into_raw(Box::new(pass)),
+        error_sink: command_encoder.error_sink.clone(),
     };
-    Box::into_raw(Box::new(pass_encoder))
+    Arc::into_raw(Arc::new(pass_encoder))
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_command_encoder_clear_buffer(
-    command_encoder: *mut CanvasGPUCommandEncoder,
+    command_encoder: *const CanvasGPUCommandEncoder,
     buffer: *const CanvasGPUBuffer,
     offset: i64,
     size: i64,
@@ -222,24 +244,33 @@ pub unsafe extern "C" fn canvas_native_webgpu_command_encoder_clear_buffer(
         return;
     }
 
-    let command_encoder = &mut *command_encoder;
+    let command_encoder = &*command_encoder;
     let command_encoder_id = command_encoder.encoder;
     let buffer = &*buffer;
     let buffer_id = buffer.buffer;
     let offset: u64 = offset.try_into().unwrap_or_default();
     let size = size.try_into().ok();
 
-    let global = &command_encoder.instance.0;
+    let global = command_encoder.instance.global();
+
+    let error_sink = command_encoder.error_sink.as_ref();
 
-    if let Err(_) = gfx_select!(buffer_id => global.command_encoder_clear_buffer(command_encoder_id, buffer_id, offset, size))
+    if let Err(cause) = gfx_select!(buffer_id => global.command_encoder_clear_buffer(command_encoder_id, buffer_id, offset, size))
     {
-        // todo handle error
+        handle_error(
+            global,
+            error_sink,
+            cause,
+            "",
+            None,
+            "canvas_native_webgpu_command_encoder_clear_buffer",
+        );
     }
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_command_encoder_copy_buffer_to_buffer(
-    command_encoder: *mut CanvasGPUCommandEncoder,
+    command_encoder: *const CanvasGPUCommandEncoder,
     src: *const CanvasGPUBuffer,
     src_offset: i64,
     dst: *const CanvasGPUBuffer,
@@ -250,7 +281,7 @@ pub unsafe extern "C" fn canvas_native_webgpu_command_encoder_copy_buffer_to_buf
         return;
     }
 
-    let command_encoder = &mut *command_encoder;
+    let command_encoder = &*command_encoder;
     let command_encoder_id = command_encoder.encoder;
     let src = &*src;
     let src_id = src.buffer;
@@ -260,17 +291,24 @@ pub unsafe extern "C" fn canvas_native_webgpu_command_encoder_copy_buffer_to_buf
     let dst_id = dst.buffer;
     let dst_offset: u64 = dst_offset.try_into().unwrap_or_default();
 
-    let global = &command_encoder.instance.0;
-
-    if let Err(_) = gfx_select!(command_encoder_id => global.command_encoder_copy_buffer_to_buffer(command_encoder_id, src_id, src_offset, dst_id, dst_offset, size))
+    let global = command_encoder.instance.global();
+    let error_sink = command_encoder.error_sink.as_ref();
+    if let Err(cause) = gfx_select!(command_encoder_id => global.command_encoder_copy_buffer_to_buffer(command_encoder_id, src_id, src_offset, dst_id, dst_offset, size))
     {
-        // todo handle error
+        handle_error(
+            global,
+            error_sink,
+            cause,
+            "",
+            None,
+            "canvas_native_webgpu_command_encoder_copy_buffer_to_buffer",
+        );
     }
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_command_encoder_copy_buffer_to_texture(
-    command_encoder: *mut CanvasGPUCommandEncoder,
+    command_encoder: *const CanvasGPUCommandEncoder,
     src: *const CanvasImageCopyBuffer,
     dst: *const CanvasImageCopyTexture,
     copy_size: *const CanvasExtent3d,
@@ -279,21 +317,17 @@ pub unsafe extern "C" fn canvas_native_webgpu_command_encoder_copy_buffer_to_tex
         return;
     }
 
-    let command_encoder = &mut *command_encoder;
+    let command_encoder = &*command_encoder;
     let command_encoder_id = command_encoder.encoder;
     let src = &*src;
     let src_buffer = &*src.buffer;
 
-    if (src.buffer.is_null()) {
-        return;
-    }
-
     let src_buffer_id = src_buffer.buffer;
     let dst = &*dst;
     let dst_texture = &*dst.texture;
     let dst_texture_id = dst_texture.texture;
 
-    let global = &command_encoder.instance.0;
+    let global = command_encoder.instance.global();
 
     let layout = wgpu_types::ImageDataLayout {
         offset: src.offset,
@@ -302,7 +336,7 @@ pub unsafe extern "C" fn canvas_native_webgpu_command_encoder_copy_buffer_to_tex
     };
     let image_copy_buffer = wgpu_types::ImageCopyBuffer {
         buffer: src_buffer_id,
-        layout: layout,
+        layout,
     };
 
     let image_copy_texture = wgpu_types::ImageCopyTexture {
@@ -315,15 +349,23 @@ pub unsafe extern "C" fn canvas_native_webgpu_command_encoder_copy_buffer_to_tex
     let copy_size = *copy_size;
     let copy_size: wgpu_types::Extent3d = copy_size.into();
 
-    if let Err(_) = gfx_select!(command_encoder_id => global.command_encoder_copy_buffer_to_texture(command_encoder_id, &image_copy_buffer, &image_copy_texture, &copy_size))
+    let error_sink = command_encoder.error_sink.as_ref();
+    if let Err(cause) = gfx_select!(command_encoder_id => global.command_encoder_copy_buffer_to_texture(command_encoder_id, &image_copy_buffer, &image_copy_texture, &copy_size))
     {
-        // todo handle error
+        handle_error(
+            global,
+            error_sink,
+            cause,
+            "",
+            None,
+            "canvas_native_webgpu_command_encoder_copy_buffer_to_texture",
+        );
     }
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_command_encoder_copy_texture_to_buffer(
-    command_encoder: *mut CanvasGPUCommandEncoder,
+    command_encoder: *const CanvasGPUCommandEncoder,
     src: *const CanvasImageCopyTexture,
     dst: *const CanvasImageCopyBuffer,
     copy_size: *const CanvasExtent3d,
@@ -332,27 +374,21 @@ pub unsafe extern "C" fn canvas_native_webgpu_command_encoder_copy_texture_to_bu
         return;
     }
 
-    let command_encoder = &mut *command_encoder;
+    let command_encoder = &*command_encoder;
     let command_encoder_id = command_encoder.encoder;
     let src = &*src;
 
-    if (src.texture.is_null()) {
-        return;
-    }
     let src_texture = &*src.texture;
 
     let src_texture_id = src_texture.texture;
     let dst = &*dst;
 
-    if dst.buffer.is_null() {
-        return;
-    }
 
     let dst_buffer = &*dst.buffer;
 
     let dst_buffer_id = dst_buffer.buffer;
 
-    let global = &command_encoder.instance.0;
+    let global = command_encoder.instance.global();
 
     let layout = wgpu_types::ImageDataLayout {
         offset: dst.offset,
@@ -361,7 +397,7 @@ pub unsafe extern "C" fn canvas_native_webgpu_command_encoder_copy_texture_to_bu
     };
     let image_copy_buffer = wgpu_types::ImageCopyBuffer {
         buffer: dst_buffer_id,
-        layout: layout,
+        layout,
     };
 
     let image_copy_texture = wgpu_types::ImageCopyTexture {
@@ -373,16 +409,23 @@ pub unsafe extern "C" fn canvas_native_webgpu_command_encoder_copy_texture_to_bu
 
     let copy_size = *copy_size;
     let copy_size: wgpu_types::Extent3d = copy_size.into();
-
-    if let Err(_) = gfx_select!(command_encoder_id => global.command_encoder_copy_texture_to_buffer(command_encoder_id, &image_copy_texture, &image_copy_buffer, &copy_size))
+    let error_sink = command_encoder.error_sink.as_ref();
+    if let Err(cause) = gfx_select!(command_encoder_id => global.command_encoder_copy_texture_to_buffer(command_encoder_id, &image_copy_texture, &image_copy_buffer, &copy_size))
     {
-        // todo handle error
+        handle_error(
+            global,
+            error_sink,
+            cause,
+            "",
+            None,
+            "canvas_native_webgpu_command_encoder_copy_texture_to_buffer",
+        );
     }
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_command_encoder_copy_texture_to_texture(
-    command_encoder: *mut CanvasGPUCommandEncoder,
+    command_encoder: *const CanvasGPUCommandEncoder,
     src: *const CanvasImageCopyTexture,
     dst: *const CanvasImageCopyTexture,
     copy_size: *const CanvasExtent3d,
@@ -391,28 +434,21 @@ pub unsafe extern "C" fn canvas_native_webgpu_command_encoder_copy_texture_to_te
         return;
     }
 
-    let command_encoder = &mut *command_encoder;
+    let command_encoder = &*command_encoder;
     let command_encoder_id = command_encoder.encoder;
     let src = &*src;
 
-    if (src.texture.is_null()) {
-        return;
-    }
-
     let src_texture = &*src.texture;
 
     let src_texture_id = src_texture.texture;
     let dst = &*dst;
 
-    if dst.texture.is_null() {
-        return;
-    }
 
     let dst_texture = &*dst.texture;
 
     let dst_texture_id = dst_texture.texture;
 
-    let global = &command_encoder.instance.0;
+    let global = command_encoder.instance.global();
 
     let image_copy_texture_src = wgpu_types::ImageCopyTexture {
         texture: src_texture_id,
@@ -431,43 +467,53 @@ pub unsafe extern "C" fn canvas_native_webgpu_command_encoder_copy_texture_to_te
     let copy_size = *copy_size;
     let copy_size: wgpu_types::Extent3d = copy_size.into();
 
-    if let Err(_) = gfx_select!(command_encoder_id => global.command_encoder_copy_texture_to_texture(command_encoder_id, &image_copy_texture_src, &image_copy_texture_dst, &copy_size))
+    let error_sink = command_encoder.error_sink.as_ref();
+    if let Err(cause) = gfx_select!(command_encoder_id => global.command_encoder_copy_texture_to_texture(command_encoder_id, &image_copy_texture_src, &image_copy_texture_dst, &copy_size))
     {
-        // todo handle error
+        handle_error(
+            global,
+            error_sink,
+            cause,
+            "",
+            None,
+            "canvas_native_webgpu_command_encoder_copy_texture_to_texture",
+        );
     }
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_command_encoder_finish(
-    command_encoder: *mut CanvasGPUCommandEncoder,
+    command_encoder: *const CanvasGPUCommandEncoder,
     label: *const c_char,
-) -> *mut CanvasGPUCommandBuffer {
+) -> *const CanvasGPUCommandBuffer {
     if command_encoder.is_null() {
         return std::ptr::null_mut();
     }
 
-    let command_encoder = &mut *command_encoder;
+    let command_encoder = &*command_encoder;
     let command_encoder_id = command_encoder.encoder;
-    let global = &command_encoder.instance.0;
+    let global = command_encoder.instance.global();
 
-    let label = if !label.is_null() {
-        Some(unsafe { CStr::from_ptr(label).to_string_lossy() })
-    } else {
-        None
-    };
+    let label = ptr_into_label(label);
 
-    let desc = wgpu_types::CommandBufferDescriptor { label: label };
+    let desc = wgpu_types::CommandBufferDescriptor { label };
 
     let (id, err) =
         gfx_select!(command_encoder_id => global.command_encoder_finish(command_encoder_id, &desc));
 
-    if let Some(error) = err {
-        println!("canvas_native_webgpu_command_encoder_finish: error {:?}", error.to_string());
-        // todo handle error
-        return std::ptr::null_mut();
+    let error_sink = command_encoder.error_sink.as_ref();
+    if let Some(cause) = err {
+        handle_error(
+            global,
+            error_sink,
+            cause,
+            "",
+            None,
+            "canvas_native_webgpu_command_encoder_finish",
+        );
     }
 
-    Box::into_raw(Box::new(CanvasGPUCommandBuffer {
+    Arc::into_raw(Arc::new(CanvasGPUCommandBuffer {
         instance: command_encoder.instance.clone(),
         command_buffer: id,
     }))
@@ -475,45 +521,60 @@ pub unsafe extern "C" fn canvas_native_webgpu_command_encoder_finish(
 
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_command_encoder_pop_debug_group(
-    command_encoder: *mut CanvasGPUCommandEncoder,
+    command_encoder: *const CanvasGPUCommandEncoder,
 ) {
     if command_encoder.is_null() {
         return;
     }
 
-    let command_encoder = &mut *command_encoder;
+    let command_encoder = &*command_encoder;
     let command_encoder_id = command_encoder.encoder;
-    let global = &command_encoder.instance.0;
-
-    if let Err(_) = gfx_select!(command_encoder_id => global.command_encoder_pop_debug_group(command_encoder_id))
+    let global = command_encoder.instance.global();
+    let error_sink = command_encoder.error_sink.as_ref();
+    if let Err(cause) = gfx_select!(command_encoder_id => global.command_encoder_pop_debug_group(command_encoder_id))
     {
-        // todo handle error
+        handle_error(
+            global,
+            error_sink,
+            cause,
+            "",
+            None,
+            "canvas_native_webgpu_command_encoder_pop_debug_group",
+        );
     }
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_command_encoder_push_debug_group(
-    command_encoder: *mut CanvasGPUCommandEncoder,
+    command_encoder: *const CanvasGPUCommandEncoder,
     label: *const c_char,
 ) {
     if command_encoder.is_null() || label.is_null() {
         return;
     }
 
-    let command_encoder = &mut *command_encoder;
+    let command_encoder = &*command_encoder;
     let command_encoder_id = command_encoder.encoder;
-    let global = &command_encoder.instance.0;
+    let global = command_encoder.instance.global();
 
     let label = CStr::from_ptr(label).to_string_lossy();
-    if let Err(_) = gfx_select!(command_encoder_id => global.command_encoder_push_debug_group(command_encoder_id, label.as_ref()))
+    let error_sink = command_encoder.error_sink.as_ref();
+    if let Err(cause) = gfx_select!(command_encoder_id => global.command_encoder_push_debug_group(command_encoder_id, label.as_ref()))
     {
-        // todo handle error
+        handle_error(
+            global,
+            error_sink,
+            cause,
+            "",
+            None,
+            "canvas_native_webgpu_command_encoder_push_debug_group",
+        );
     }
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_command_encoder_resolve_query_set(
-    command_encoder: *mut CanvasGPUCommandEncoder,
+    command_encoder: *const CanvasGPUCommandEncoder,
     query_set: *const CanvasGPUQuerySet,
     first_query: u32,
     query_count: u32,
@@ -524,7 +585,7 @@ pub unsafe extern "C" fn canvas_native_webgpu_command_encoder_resolve_query_set(
         return;
     }
 
-    let command_encoder = &mut *command_encoder;
+    let command_encoder = &*command_encoder;
     let command_encoder_id = command_encoder.encoder;
 
     let query_set = &*query_set;
@@ -533,16 +594,24 @@ pub unsafe extern "C" fn canvas_native_webgpu_command_encoder_resolve_query_set(
     let dst = &*dst;
     let dst_id = dst.buffer;
 
-    let global = &command_encoder.instance.0;
-
-    if let Err(_) = gfx_select!(command_encoder_id => global.command_encoder_resolve_query_set(command_encoder_id, query_set_id, first_query, query_count, dst_id, dst_offset))
+    let global = command_encoder.instance.global();
+    let error_sink = command_encoder.error_sink.as_ref();
+    if let Err(cause) = gfx_select!(command_encoder_id => global.command_encoder_resolve_query_set(command_encoder_id, query_set_id, first_query, query_count, dst_id, dst_offset))
     {
+        handle_error(
+            global,
+            error_sink,
+            cause,
+            "",
+            None,
+            "canvas_native_webgpu_command_encoder_resolve_query_set",
+        );
     }
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_command_encoder_write_timestamp(
-    command_encoder: *mut CanvasGPUCommandEncoder,
+    command_encoder: *const CanvasGPUCommandEncoder,
     query_set: *const CanvasGPUQuerySet,
     query_index: u32,
 ) {
@@ -550,15 +619,23 @@ pub unsafe extern "C" fn canvas_native_webgpu_command_encoder_write_timestamp(
         return;
     }
 
-    let command_encoder = &mut *command_encoder;
+    let command_encoder = &*command_encoder;
     let command_encoder_id = command_encoder.encoder;
 
     let query_set = &*query_set;
     let query_set_id = query_set.query;
 
-    let global = &command_encoder.instance.0;
-
-    if let Err(_) = gfx_select!(command_encoder_id => global.command_encoder_write_timestamp(command_encoder_id, query_set_id, query_index))
+    let global = command_encoder.instance.global();
+    let error_sink = command_encoder.error_sink.as_ref();
+    if let Err(cause) = gfx_select!(command_encoder_id => global.command_encoder_write_timestamp(command_encoder_id, query_set_id, query_index))
     {
+        handle_error(
+            global,
+            error_sink,
+            cause,
+            "",
+            None,
+            "canvas_native_webgpu_command_encoder_write_timestamp",
+        );
     }
 }
diff --git a/crates/canvas-c/src/webgpu/gpu_compute_pass.rs b/crates/canvas-c/src/webgpu/gpu_compute_pass.rs
deleted file mode 100644
index 511e591e8..000000000
--- a/crates/canvas-c/src/webgpu/gpu_compute_pass.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-use super::gpu::CanvasWebGPUInstance;
-
-pub struct CanvasGPUComputePass {
-    pub(crate) instance: CanvasWebGPUInstance,
-    pub(crate) pass: wgpu_core::command::ComputePass,
-}
diff --git a/crates/canvas-c/src/webgpu/gpu_compute_pass_encoder.rs b/crates/canvas-c/src/webgpu/gpu_compute_pass_encoder.rs
new file mode 100644
index 000000000..840703cd4
--- /dev/null
+++ b/crates/canvas-c/src/webgpu/gpu_compute_pass_encoder.rs
@@ -0,0 +1,245 @@
+use std::borrow::Cow;
+use std::ffi::CStr;
+use std::os::raw::c_char;
+use std::sync::Arc;
+
+use crate::webgpu::error::handle_error;
+use crate::webgpu::gpu_bind_group::CanvasGPUBindGroup;
+use crate::webgpu::gpu_buffer::CanvasGPUBuffer;
+use crate::webgpu::gpu_compute_pipeline::CanvasGPUComputePipeline;
+
+use super::gpu::CanvasWebGPUInstance;
+
+pub struct CanvasGPUComputePassEncoder {
+    pub(crate) label: Option<Cow<'static, str>>,
+    pub(crate) instance: Arc<CanvasWebGPUInstance>,
+    pub(crate) pass: *mut wgpu_core::command::ComputePass,
+    pub(crate) error_sink: super::gpu_device::ErrorSink,
+}
+
+impl Drop for CanvasGPUComputePassEncoder {
+    fn drop(&mut self) {
+        if !std::thread::panicking() {
+            drop(unsafe { Box::from_raw(self.pass) });
+        }
+    }
+}
+// CanvasGPUComputePassEncoder is thread-unsafe
+unsafe impl Send for CanvasGPUComputePassEncoder {}
+unsafe impl Sync for CanvasGPUComputePassEncoder {}
+
+#[no_mangle]
+pub unsafe extern "C" fn canvas_native_webgpu_compute_pass_reference(
+    compute_pass: *const CanvasGPUComputePassEncoder
+) {
+    if compute_pass.is_null() {
+        return;
+    }
+    Arc::increment_strong_count(compute_pass);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn canvas_native_webgpu_compute_pass_release(
+    compute_pass: *const CanvasGPUComputePassEncoder
+) {
+    if compute_pass.is_null() {
+        return;
+    }
+    Arc::decrement_strong_count(compute_pass);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn canvas_native_webgpu_compute_pass_dispatch_workgroups(
+    compute_pass: *const CanvasGPUComputePassEncoder,
+    workgroup_count_x: u32,
+    workgroup_count_y: u32,
+    workgroup_count_z: u32,
+) {
+    if compute_pass.is_null() {
+        return;
+    }
+
+    let compute_pass = &*compute_pass;
+    let compute_pass = &mut *compute_pass.pass;
+
+    wgpu_core::command::compute_commands::wgpu_compute_pass_dispatch_workgroups(compute_pass, workgroup_count_x, workgroup_count_y, workgroup_count_z)
+}
+
+
+#[no_mangle]
+pub unsafe extern "C" fn canvas_native_webgpu_compute_pass_dispatch_workgroups_indirect(
+    compute_pass: *const CanvasGPUComputePassEncoder,
+    indirect_buffer: *const CanvasGPUBuffer,
+    indirect_offset: usize,
+) {
+    if compute_pass.is_null() {
+        return;
+    }
+
+    let compute_pass = &*compute_pass;
+    let compute_pass = &mut *compute_pass.pass;
+
+    let indirect_buffer = &*indirect_buffer;
+    let indirect_buffer = indirect_buffer.buffer;
+
+    wgpu_core::command::compute_commands::wgpu_compute_pass_dispatch_workgroups_indirect(compute_pass, indirect_buffer, indirect_offset as u64)
+}
+
+
+#[no_mangle]
+pub unsafe extern "C" fn canvas_native_webgpu_compute_pass_end(
+    compute_pass: *const CanvasGPUComputePassEncoder,
+) {
+    if compute_pass.is_null() {
+        return;
+    }
+
+    let compute_pass = &*compute_pass;
+    let label = compute_pass.label.clone();
+    let error_sink = compute_pass.error_sink.as_ref();
+
+    let global = compute_pass.instance.global();
+
+    let compute_pass = &mut *compute_pass.pass;
+
+    let command_encoder_id = compute_pass.parent_id();
+
+
+    if let Err(cause) = gfx_select!(command_encoder_id =>   global.command_encoder_run_compute_pass(command_encoder_id, compute_pass)) {
+        handle_error(
+            global,
+            error_sink,
+            cause,
+            "encoder",
+            label,
+            "canvas_native_webgpu_compute_pass_end",
+        );
+    }
+}
+
+
+#[no_mangle]
+pub unsafe extern "C" fn canvas_native_webgpu_compute_pass_insert_debug_marker(
+    compute_pass: *const CanvasGPUComputePassEncoder,
+    label: *const c_char,
+) {
+    if compute_pass.is_null() || label.is_null() {
+        return;
+    }
+
+    let compute_pass = &*compute_pass;
+    let compute_pass = &mut *compute_pass.pass;
+
+    let label = CStr::from_ptr(label);
+    let label = label.to_string_lossy();
+
+    wgpu_core::command::compute_commands::wgpu_compute_pass_insert_debug_marker(
+        compute_pass,
+        label.as_ref(),
+        0,
+    );
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn canvas_native_webgpu_compute_pass_pop_debug_group(
+    compute_pass: *const CanvasGPUComputePassEncoder,
+) {
+    if compute_pass.is_null() {
+        return;
+    }
+
+    let compute_pass = &*compute_pass;
+    let compute_pass = &mut *compute_pass.pass;
+
+    wgpu_core::command::compute_commands::wgpu_compute_pass_pop_debug_group(compute_pass);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn canvas_native_webgpu_compute_pass_push_debug_group(
+    compute_pass: *const CanvasGPUComputePassEncoder,
+    label: *const c_char,
+) {
+    if compute_pass.is_null() || label.is_null() {
+        return;
+    }
+
+    let compute_pass = &*compute_pass;
+    let compute_pass = &mut *compute_pass.pass;
+
+    let label = CStr::from_ptr(label);
+    let label = label.to_string_lossy();
+
+    wgpu_core::command::compute_commands::wgpu_compute_pass_push_debug_group(
+        compute_pass,
+        label.as_ref(),
+        0,
+    );
+}
+
+
+#[no_mangle]
+pub unsafe extern "C" fn canvas_native_webgpu_compute_pass_set_bind_group(
+    compute_pass: *const CanvasGPUComputePassEncoder,
+    index: u32,
+    bind_group: *const CanvasGPUBindGroup,
+    dynamic_offsets: *const u32,
+    dynamic_offsets_size: usize,
+    dynamic_offsets_start: usize,
+    dynamic_offsets_length: usize,
+) {
+    if compute_pass.is_null() || bind_group.is_null() {
+        return;
+    }
+
+    let compute_pass = &*compute_pass;
+    let compute_pass = &mut *compute_pass.pass;
+
+    let bind_group = &*bind_group;
+    let bind_group_id = bind_group.group;
+
+    if !dynamic_offsets.is_null() && dynamic_offsets_size > 0 {
+        let dynamic_offsets = std::slice::from_raw_parts(dynamic_offsets, dynamic_offsets_size);
+
+        let start = dynamic_offsets_start;
+        let len = dynamic_offsets_length;
+
+        // Assert that length and start are both in bounds
+        assert!(start <= dynamic_offsets.len());
+        assert!(len <= dynamic_offsets.len() - start);
+
+        let dynamic_offsets: &[u32] = &dynamic_offsets[start..start + len];
+
+        wgpu_core::command::compute_commands::wgpu_compute_pass_set_bind_group(
+            compute_pass,
+            index,
+            bind_group_id,
+            dynamic_offsets,
+        );
+    } else {
+        wgpu_core::command::compute_commands::wgpu_compute_pass_set_bind_group(
+            compute_pass,
+            index,
+            bind_group_id,
+            &[],
+        );
+    }
+}
+
+
+#[no_mangle]
+pub unsafe extern "C" fn canvas_native_webgpu_compute_pass_set_pipeline(
+    compute_pass: *mut CanvasGPUComputePassEncoder,
+    pipeline: *const CanvasGPUComputePipeline,
+) {
+    if compute_pass.is_null() || pipeline.is_null() {
+        return;
+    }
+
+    let compute_pass = &*compute_pass;
+    let compute_pass = &mut *compute_pass.pass;
+
+    let pipeline = &*pipeline;
+    let pipeline_id = pipeline.pipeline;
+
+    wgpu_core::command::compute_commands::wgpu_compute_pass_set_pipeline(compute_pass, pipeline_id);
+}
diff --git a/crates/canvas-c/src/webgpu/gpu_compute_pipeline.rs b/crates/canvas-c/src/webgpu/gpu_compute_pipeline.rs
new file mode 100644
index 000000000..e7ce59a88
--- /dev/null
+++ b/crates/canvas-c/src/webgpu/gpu_compute_pipeline.rs
@@ -0,0 +1,45 @@
+use std::sync::Arc;
+
+use crate::webgpu::error::handle_error;
+use crate::webgpu::gpu::CanvasWebGPUInstance;
+use crate::webgpu::gpu_bind_group_layout::CanvasGPUBindGroupLayout;
+
+pub struct CanvasGPUComputePipeline {
+    pub(crate) instance: Arc<CanvasWebGPUInstance>,
+    pub(crate) pipeline: wgpu_core::id::ComputePipelineId,
+    pub(crate) error_sink: super::gpu_device::ErrorSink,
+}
+
+
+#[no_mangle]
+pub unsafe extern "C" fn canvas_native_webgpu_compute_pipeline_get_bind_group_layout(
+    pipeline: *const CanvasGPUComputePipeline,
+    index: u32,
+) -> *const CanvasGPUBindGroupLayout {
+    if pipeline.is_null() {
+        return std::ptr::null_mut();
+    }
+
+    let pipeline = &*pipeline;
+    let pipeline_id = pipeline.pipeline;
+
+    let global = pipeline.instance.global();
+    let error_sink = pipeline.error_sink.as_ref();
+    let (group_layout, error) = gfx_select!(pipeline_id => global.compute_pipeline_get_bind_group_layout(pipeline_id, index, None));
+
+    if let Some(cause) = error {
+        handle_error(
+            global,
+            error_sink,
+            cause,
+            "",
+            None,
+            "canvas_native_webgpu_compute_pipeline_get_bind_group_layout",
+        );
+    }
+
+    Arc::into_raw(Arc::new(CanvasGPUBindGroupLayout {
+        instance: pipeline.instance.clone(),
+        group_layout,
+    }))
+}
diff --git a/crates/canvas-c/src/webgpu/gpu_device.rs b/crates/canvas-c/src/webgpu/gpu_device.rs
index b7b55b44e..fb5090511 100644
--- a/crates/canvas-c/src/webgpu/gpu_device.rs
+++ b/crates/canvas-c/src/webgpu/gpu_device.rs
@@ -4,14 +4,29 @@ use std::{
     ffi::{CStr, CString},
     os::raw::{c_char, c_void},
 };
+use std::cmp::PartialEq;
+use std::num::NonZeroU64;
+use std::sync::Arc;
+
+use wgpu_core::binding_model::BufferBinding;
+use wgpu_core::command::{CreateRenderBundleError, RenderBundleEncoder};
+use wgpu_core::resource::CreateBufferError;
 
 use crate::buffers::StringBuffer;
+use crate::webgpu::enums::{CanvasAddressMode, CanvasBindGroupEntry, CanvasBindGroupEntryResource, CanvasBindGroupLayoutEntry, CanvasFilterMode, CanvasOptionalCompareFunction, CanvasQueryType};
+use crate::webgpu::error::{CanvasGPUError, CanvasGPUErrorType, handle_error, handle_error_fatal};
+use crate::webgpu::gpu_bind_group::CanvasGPUBindGroup;
+use crate::webgpu::gpu_bind_group_layout::CanvasGPUBindGroupLayout;
+use crate::webgpu::gpu_compute_pipeline::CanvasGPUComputePipeline;
+use crate::webgpu::gpu_query_set::CanvasGPUQuerySet;
+use crate::webgpu::gpu_render_bundle_encoder::CanvasGPURenderBundleEncoder;
+use crate::webgpu::gpu_sampler::CanvasGPUSampler;
 
 use super::{
     enums::{
-        CanvasCompareFunction, CanvasCullMode, CanvasFrontFace, CanvasGPUTextureFormat,
-        CanvasIndexFormat, CanvasOptionalFrontFace, CanvasOptionalIndexFormat,
-        CanvasOptionalPrimitiveTopology, CanvasPrimitiveTopology, CanvasStencilFaceState,
+        CanvasCompareFunction, CanvasCullMode, CanvasFrontFace, CanvasGPUTextureFormat
+        , CanvasOptionalIndexFormat
+        , CanvasPrimitiveTopology, CanvasStencilFaceState,
         CanvasTextureDimension, CanvasVertexStepMode,
     },
     gpu::CanvasWebGPUInstance,
@@ -29,80 +44,328 @@ use super::{
 
 const MAX_BIND_GROUPS: usize = 8;
 
+#[derive(Clone, Copy, Debug, Eq, PartialEq, PartialOrd)]
+pub enum ErrorFilter {
+    /// Catch only out-of-memory errors.
+    OutOfMemory,
+    /// Catch only validation errors.
+    Validation,
+    /// Catch only internal errors.
+    Internal,
+}
+
+
+pub(crate) type ErrorSink = Arc<parking_lot::Mutex<ErrorSinkRaw>>;
+
+struct ErrorScope {
+    error: Option<CanvasGPUError>,
+    filter: ErrorFilter,
+}
+
+pub struct DeviceCallback<T> {
+    callback: T,
+    userdata: *mut c_void,
+}
+unsafe impl<T> Send for DeviceCallback<T> {}
+
+pub(crate) type GPUErrorCallback = Option<unsafe extern "C" fn(CanvasGPUErrorType, *mut c_char, *mut c_void)>;
+pub(crate) type GPUDeviceLostCallback = Option<unsafe extern "C" fn(i32, *mut c_char, *mut c_void)>;
+pub(crate) type UncapturedErrorCallback = DeviceCallback<GPUErrorCallback>;
+pub(crate) type DeviceLostCallback = DeviceCallback<GPUDeviceLostCallback>;
+
+unsafe extern "C" fn default_uncaptured_error_handler(
+    _typ: super::error::CanvasGPUErrorType,
+    message: *mut ::std::os::raw::c_char,
+    _userdata: *mut ::std::os::raw::c_void,
+) {
+    let message = unsafe { CStr::from_ptr(message) }.to_str().unwrap();
+    log::warn!("Handling webgpu uncaptured errors as fatal by default");
+    log::error!("webgpu uncaptured error:\n{message}\n");
+}
+
+const DEFAULT_UNCAPTURED_ERROR_HANDLER: UncapturedErrorCallback = UncapturedErrorCallback {
+    callback: Some(default_uncaptured_error_handler),
+    userdata: std::ptr::null_mut(),
+};
+
+pub(crate) unsafe extern "C" fn default_device_lost_handler(
+    _reason: i32,
+    message: *mut c_char,
+    _userdata: *mut c_void,
+) {
+    let message = unsafe { CStr::from_ptr(message) }.to_str().unwrap();
+    log::warn!("Handling webgpu device lost errors as fatal by default");
+    log::error!("webgpu device lost error:\n{message}\n");
+}
+pub const DEFAULT_DEVICE_LOST_HANDLER: DeviceLostCallback = DeviceLostCallback {
+    callback: Some(default_device_lost_handler),
+    userdata: std::ptr::null_mut(),
+};
+
+pub struct ErrorSinkRaw {
+    scopes: Vec<ErrorScope>,
+    uncaptured_handler: UncapturedErrorCallback,
+    device_lost_handler: DeviceLostCallback,
+}
+
+impl PartialEq for CanvasGPUError {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (CanvasGPUError::Internal, CanvasGPUError::Internal) => true,
+            (CanvasGPUError::OutOfMemory, CanvasGPUError::OutOfMemory) => true,
+            (CanvasGPUError::Lost, CanvasGPUError::Lost) => true,
+            (CanvasGPUError::Validation(_), CanvasGPUError::Validation(_)) => true,
+            _ => false
+        }
+    }
+}
+
+impl ErrorSinkRaw {
+    pub(crate) fn new(device_lost_handler: DeviceLostCallback) -> ErrorSinkRaw {
+        ErrorSinkRaw {
+            scopes: Vec::new(),
+            uncaptured_handler: DEFAULT_UNCAPTURED_ERROR_HANDLER,
+            device_lost_handler,
+        }
+    }
+
+    pub(crate) fn handle_error(&mut self, err: CanvasGPUError) {
+        let (typ, filter) = match err {
+            super::error::CanvasGPUError::Lost { .. } => {
+                // handle device lost error early
+                if let Some(callback) = self.device_lost_handler.callback {
+                    let userdata = self.device_lost_handler.userdata;
+                    let msg = CString::new(err.to_string()).unwrap();
+                    unsafe {
+                        callback(
+                            wgpu_types::DeviceLostReason::Destroyed as i32,
+                            msg.into_raw(),
+                            userdata,
+                        );
+                    };
+                }
+                return;
+            }
+            CanvasGPUError::OutOfMemory { .. } => (
+                super::error::CanvasGPUErrorType::OutOfMemory,
+                ErrorFilter::OutOfMemory,
+            ),
+            super::error::CanvasGPUError::Validation { .. } => (
+                super::error::CanvasGPUErrorType::Validation,
+                ErrorFilter::Validation,
+            ),
+            super::error::CanvasGPUError::Internal { .. } => (
+                super::error::CanvasGPUErrorType::Internal,
+                ErrorFilter::Internal,
+            ),
+            super::error::CanvasGPUError::None { .. } => (
+                super::error::CanvasGPUErrorType::None,
+                ErrorFilter::Internal,
+            )
+        };
+
+        if typ == CanvasGPUErrorType::None {
+            return;
+        }
+
+        match self
+            .scopes
+            .iter_mut()
+            .rev()
+            .find(|scope| scope.filter == filter)
+        {
+            Some(scope) => {
+                if scope.error.is_none() {
+                    scope.error = Some(err);
+                }
+            }
+            None => {
+                if let Some(callback) = self.uncaptured_handler.callback {
+                    let userdata = self.uncaptured_handler.userdata;
+                    let msg = CString::new(err.to_string()).unwrap();
+                    unsafe { callback(typ, msg.into_raw(), userdata) };
+                }
+            }
+        }
+    }
+}
+
 pub struct CanvasGPUDevice {
-    pub(crate) instance: CanvasWebGPUInstance,
+    pub(crate) instance: Arc<CanvasWebGPUInstance>,
     pub(crate) device: wgpu_core::id::DeviceId,
-    pub(crate) queue: CanvasGPUQueue,
+    pub(crate) queue: Arc<CanvasGPUQueue>,
+    pub(crate) user_data: *mut c_void,
+    pub(crate) error_sink: ErrorSink,
 }
 
-impl CanvasGPUDevice {
-    // pub fn createBindGroup(&self, descriptor) {
-    //     self.device.create_bind_group(desc)
-    // }
-
-    // pub fn createBindGroupLayout(&self, descriptor){}
 
+impl CanvasGPUDevice {
     pub fn features(&self) -> Result<wgpu_types::Features, wgpu_core::device::InvalidDevice> {
         let device_id = self.device;
-        let global = &self.instance.0;
+        let global = self.instance.global();
         gfx_select!(device_id => global.device_features(device_id))
     }
 
     pub fn destroy(&self) {
         let device_id = self.device;
-        let global = &self.instance.0;
+        let global = self.instance.global();
         gfx_select!(device_id => global.device_destroy(device_id));
     }
 
+    pub fn create_bind_group(&self, label: Option<Cow<'static, str>>, layout: &CanvasGPUBindGroupLayout, entries: &[CanvasBindGroupEntry]) -> *const CanvasGPUBindGroup {
+        let global = self.instance.global();
+        let layout_id = layout.group_layout;
+        let entries = entries.iter().map(|entry| {
+            wgpu_core::binding_model::BindGroupEntry {
+                binding: entry.binding,
+                resource: match &entry.resource {
+                    CanvasBindGroupEntryResource::Buffer(buffer) => {
+                        let buf = unsafe { &*buffer.buffer };
+                        wgpu_core::binding_model::BindingResource::Buffer(
+                            BufferBinding {
+                                buffer_id: buf.buffer,
+                                offset: buffer.offset.try_into().ok().unwrap_or_default(),
+                                size: buffer.size.try_into().map(|value: u64| NonZeroU64::new(value))
+                                    .ok()
+                                    .flatten(),
+                            }
+                        )
+                    }
+                    CanvasBindGroupEntryResource::Sampler(sampler) => {
+                        let sampler = unsafe { &**sampler };
+                        wgpu_core::binding_model::BindingResource::Sampler(sampler.sampler)
+                    }
+                    CanvasBindGroupEntryResource::TextureView(view) => {
+                        let view = unsafe { &**view };
+                        wgpu_core::binding_model::BindingResource::TextureView(view.texture_view)
+                    }
+                },
+            }
+        })
+            .collect::<Vec<_>>();
+        let desc = wgpu_core::binding_model::BindGroupDescriptor {
+            label: label.clone(),
+            layout: layout_id,
+            entries: Cow::from(entries),
+        };
+        let device_id = self.device;
+        let (group, error) = gfx_select!(device_id => global.device_create_bind_group(device_id, &desc, None));
+
+        let error_sink = self.error_sink.as_ref();
+        if let Some(cause) = error {
+            handle_error(
+                global,
+                error_sink,
+                cause,
+                "label",
+                desc.label,
+                "canvas_native_webgpu_device_create_bind_group",
+            );
+        };
+
+        Arc::into_raw(
+            Arc::new(CanvasGPUBindGroup {
+                label,
+                instance: self.instance.clone(),
+                group,
+            })
+        )
+    }
+
+    pub fn create_bind_group_layout(&self, label: Option<Cow<'static, str>>, entries: &[CanvasBindGroupLayoutEntry]) -> *const CanvasGPUBindGroupLayout {
+        let global = self.instance.global();
+        let entries = entries.iter().map(|entry| (*entry).into())
+            .collect::<Vec<_>>();
+        let desc = wgpu_core::binding_model::BindGroupLayoutDescriptor { label: label.clone(), entries: Cow::from(entries) };
+
+        let device_id = self.device;
+        let (group_layout_id, error) = gfx_select!(device_id => global.device_create_bind_group_layout(device_id, &desc, None));
+
+        let error_sink = self.error_sink.as_ref();
+        if let Some(cause) = error {
+            handle_error(
+                global,
+                error_sink,
+                cause,
+                "label",
+                desc.label,
+                "canvas_native_webgpu_device_create_bind_group_layout",
+            );
+        }
+        Arc::into_raw(
+            Arc::new(
+                CanvasGPUBindGroupLayout {
+                    instance: self.instance.clone(),
+                    group_layout: group_layout_id,
+                }
+            )
+        )
+    }
+
     pub fn create_buffer(
         &self,
         label: *const c_char,
         size: u64,
         usage: u32,
         mapped_at_creation: bool,
-        mut error: *mut c_char,
-    ) -> *mut CanvasGPUBuffer {
-        let label = if !label.is_null() {
-            Some(unsafe { CStr::from_ptr(label).to_string_lossy() })
-        } else {
-            None
-        };
+    ) -> *const CanvasGPUBuffer {
+        let label = ptr_into_label(label);
+        let global = self.instance.global();
+
         match wgpu_types::BufferUsages::from_bits(usage) {
             Some(usage) => {
                 let desc = wgpu_types::BufferDescriptor {
                     label: label.clone(),
-                    size: size,
-                    usage: usage,
-                    mapped_at_creation: mapped_at_creation,
+                    size,
+                    usage,
+                    mapped_at_creation,
                 };
 
                 let device_id = self.device;
-                let global = &self.instance.0;
+
                 let (buffer, err) =
                     gfx_select!(device_id => global.device_create_buffer(device_id, &desc, None));
 
-                // todo handle error
-                if let Some(_) = err {
-                    error = CString::new("usage is not valid").unwrap().into_raw();
-                    std::ptr::null_mut()
-                } else {
-                    Box::into_raw(Box::new(CanvasGPUBuffer {
-                        instance: self.instance.clone(),
-                        label: label.unwrap_or_default(),
-                        buffer,
-                        usage: usage.bits(),
-                        size,
-                    }))
+                let error_sink = self.error_sink.as_ref();
+                if let Some(cause) = err {
+                    handle_error(
+                        global,
+                        error_sink,
+                        cause,
+                        "label",
+                        desc.label,
+                        "canvas_native_webgpu_device_create_buffer",
+                    );
                 }
+
+                Arc::into_raw(Arc::new(CanvasGPUBuffer {
+                    instance: self.instance.clone(),
+                    label: label.unwrap_or_default(),
+                    buffer,
+                    usage: usage.bits(),
+                    size,
+                    error_sink: self.error_sink.clone(),
+                }))
             }
             None => {
-                error = CString::new("usage is not valid").unwrap().into_raw();
+                let err = CreateBufferError::InvalidUsage(wgpu_types::BufferUsages::from_bits_truncate(usage));
+
+                handle_error(
+                    global,
+                    self.error_sink.as_ref(),
+                    err,
+                    "label",
+                    label,
+                    "canvas_native_webgpu_device_create_buffer",
+                );
+
                 std::ptr::null_mut()
             }
         }
     }
 }
 
+
 #[no_mangle]
 pub extern "C" fn canvas_native_webgpu_device_get_features(
     device: *const CanvasGPUDevice,
@@ -125,61 +388,74 @@ pub extern "C" fn canvas_native_webgpu_device_get_limits(
     }
     let device = unsafe { &*device };
     let device_id = device.device;
-    let global = &device.instance.0;
+    let global = device.instance.global();
     match gfx_select!(device_id => global.device_limits(device_id)) {
         Ok(limits) => {
             let limits: CanvasGPUSupportedLimits = limits.into();
             Box::into_raw(Box::new(limits))
         }
-        Err(_) => std::ptr::null_mut(),
+        Err(err) => {
+            handle_error_fatal(global, err, "canvas_native_webgpu_device_get_limits");
+            std::ptr::null_mut()
+        }
     }
 }
 
 #[no_mangle]
 pub extern "C" fn canvas_native_webgpu_device_get_queue(
     device: *const CanvasGPUDevice,
-) -> *mut CanvasGPUQueue {
+) -> *const CanvasGPUQueue {
     if device.is_null() {
-        return std::ptr::null_mut();
+        return std::ptr::null();
     }
     let device = unsafe { &*device };
-    Box::into_raw(Box::new(device.queue.clone()))
+    Arc::into_raw(device.queue.clone())
 }
 
 #[no_mangle]
-pub extern "C" fn canvas_native_webgpu_device_set_lost_callback(
+pub unsafe extern "C" fn canvas_native_webgpu_device_set_lost_callback(
     device: *const CanvasGPUDevice,
-    callback: extern "C" fn(i32, *mut c_char, *mut c_void),
-    callback_data: *mut c_void,
+    callback: Option<unsafe extern "C" fn(i32, *mut c_char, *mut c_void)>,
+    userdata: *mut c_void,
 ) {
     if device.is_null() {
         return;
     }
 
-    let device = unsafe { &*device };
-    let callback = callback as i64;
-    let callback_data = callback_data as i64;
-    let callback = Box::new(move |reason, message| {
-        let callback = unsafe {
-            std::mem::transmute::<*const i64, extern "C" fn(i32, *mut c_char, *mut c_void)>(
-                callback as _,
-            )
-        };
-        let callback_data = callback_data as *mut c_void;
-        callback(
-            reason as i32,
-            CString::new(message).unwrap().into_raw(),
-            callback_data,
-        );
-    });
-
-    let device_id = device.device;
-    let global = &device.instance.0;
+    Arc::increment_strong_count(device);
+    let mut device = Arc::from_raw(device);
+    if let Some(device) = Arc::get_mut(&mut device) {
+        device.user_data = userdata;
+    }
 
-    gfx_select!(device_id => global.device_set_device_lost_closure(
-        device_id,
-        wgpu_core::device::DeviceLostClosure::from_rust(callback),
-    ));
+    let mut error_sink = device.error_sink.lock();
+    error_sink.device_lost_handler = DeviceLostCallback {
+        callback,
+        userdata,
+    };
+    // let callback = callback as i64;
+    // let callback_data = callback_data as i64;
+    // let callback = Box::new(move |reason, message| {
+    //     let callback = unsafe {
+    //         std::mem::transmute::<*const i64, extern "C" fn(i32, *mut c_char, *mut c_void)>(
+    //             callback as _,
+    //         )
+    //     };
+    //     let callback_data = callback_data as *mut c_void;
+    //     callback(
+    //         reason as i32,
+    //         CString::new(message).unwrap().into_raw(),
+    //         callback_data,
+    //     );
+    // });
+    //
+    // let device_id = device.device;
+    // let global = device.instance.global();
+    //
+    // gfx_select!(device_id => global.device_set_device_lost_closure(
+    //     device_id,
+    //     wgpu_core::device::DeviceLostClosure::from_rust(callback),
+    // ));
 }
 
 #[no_mangle]
@@ -193,19 +469,72 @@ pub extern "C" fn canvas_native_webgpu_device_destroy(device: *const CanvasGPUDe
 }
 
 #[no_mangle]
-pub extern "C" fn canvas_native_webgpu_device_destroy_destory(device: *mut CanvasGPUDevice) {
+pub unsafe extern "C" fn canvas_native_webgpu_device_reference(device: *const CanvasGPUDevice) {
     if device.is_null() {
         return;
     }
+    Arc::increment_strong_count(device);
+}
 
-    let _ = unsafe { Box::from_raw(device) };
+#[no_mangle]
+pub unsafe extern "C" fn canvas_native_webgpu_device_release(device: *const CanvasGPUDevice) {
+    if device.is_null() {
+        return;
+    }
+
+    Arc::decrement_strong_count(device);
+}
+
+
+#[no_mangle]
+pub unsafe extern "C" fn canvas_native_webgpu_device_create_bind_group_layout(
+    device: *const CanvasGPUDevice,
+    label: *const c_char,
+    entries: *const CanvasBindGroupLayoutEntry,
+    size: usize,
+) -> *const CanvasGPUBindGroupLayout {
+    if device.is_null() || entries.is_null() || size == 0 {
+        return std::ptr::null();
+    }
+
+    let device = unsafe { &*device };
+
+    let entries = std::slice::from_raw_parts(entries, size);
+
+    let label = ptr_into_label(label);
+
+    device.create_bind_group_layout(label, entries)
+}
+
+
+#[no_mangle]
+pub unsafe extern "C" fn canvas_native_webgpu_device_create_bind_group(
+    device: *const CanvasGPUDevice,
+    label: *const c_char,
+    layout: *const CanvasGPUBindGroupLayout,
+    entries: *const CanvasBindGroupEntry,
+    size: usize,
+) -> *const CanvasGPUBindGroup {
+    if device.is_null() || layout.is_null() || entries.is_null() || size == 0 {
+        return std::ptr::null();
+    }
+
+    let device = unsafe { &*device };
+
+    let entries = std::slice::from_raw_parts(entries, size);
+
+    let label = ptr_into_label(label);
+
+    let layout = &*layout;
+
+    device.create_bind_group(label, layout, entries)
 }
 
 #[no_mangle]
 pub extern "C" fn canvas_native_webgpu_device_create_command_encoder(
     device: *const CanvasGPUDevice,
     label: *const c_char,
-) -> *mut CanvasGPUCommandEncoder {
+) -> *const CanvasGPUCommandEncoder {
     if device.is_null() {
         return std::ptr::null_mut();
     }
@@ -216,70 +545,532 @@ pub extern "C" fn canvas_native_webgpu_device_create_command_encoder(
     };
 
     let device = unsafe { &*device };
-    let desc = wgpu_types::CommandEncoderDescriptor { label: label };
-    // let encoder = CanvasGPUCommandEncoder(
-    //     Arc::new(parking_lot::RwLock::new(device.device.create_command_encoder(&desc)))
-    // );
+    let desc = wgpu_types::CommandEncoderDescriptor { label };
 
-    
     let device_id = device.device;
-    let global = &device.instance.0;
-    
+    let global = &device.instance.global();
+
     let (encoder, error) =
         gfx_select!(device_id => global.device_create_command_encoder(device_id, &desc, None));
+    let error_sink = device.error_sink.as_ref();
+    if let Some(cause) = error {
+        handle_error(
+            global,
+            error_sink,
+            cause,
+            "label",
+            desc.label,
+            "canvas_native_webgpu_device_create_command_encoder",
+        );
+    }
+
+    let encoder = CanvasGPUCommandEncoder {
+        instance: device.instance.clone(),
+        encoder,
+        error_sink: device.error_sink.clone(),
+    };
+    Arc::into_raw(Arc::new(encoder))
+}
+
+
+#[repr(C)]
+pub struct CanvasProgrammableStage {
+    pub module: *const CanvasGPUShaderModule,
+    pub entry_point: *const c_char,
+    pub constants: *const CanvasConstants,
+}
+
+
+#[no_mangle]
+pub unsafe extern "C" fn canvas_native_webgpu_device_create_compute_pipeline(
+    device: *const CanvasGPUDevice,
+    label: *const c_char,
+    layout: CanvasGPUPipelineLayoutOrGPUAutoLayoutMode,
+    compute: *const CanvasProgrammableStage,
+) -> *const CanvasGPUComputePipeline {
+    if device.is_null() || compute.is_null() {
+        return std::ptr::null();
+    }
+
+    let device = &*device;
+    let device_id = device.device;
+
+    let global = device.instance.global();
+
+    let label = ptr_into_label(label);
+
+
+    let pipeline_layout = match layout {
+        CanvasGPUPipelineLayoutOrGPUAutoLayoutMode::Layout(layout) => {
+            let layout = &*layout;
+            Some(layout.layout)
+        }
+        CanvasGPUPipelineLayoutOrGPUAutoLayoutMode::Auto(CanvasGPUAutoLayoutMode::Auto) => None,
+    };
+
+    let compute = &*compute;
+
+    let entry_point = if compute.entry_point.is_null() {
+        None
+    } else {
+        Some(CStr::from_ptr(compute.entry_point).to_string_lossy())
+    };
+
+
+    let constants = if compute.constants.is_null() {
+        let constants = HashMap::default();
+        Cow::Owned(constants)
+    } else {
+        let constants = &*compute.constants;
+        Cow::Borrowed(&constants.0)
+    };
+
+    let module = &*compute.module;
+    let shader_module = module.module;
+
+
+    let desc = wgpu_core::pipeline::ComputePipelineDescriptor {
+        label,
+        layout: pipeline_layout,
+        stage: wgpu_core::pipeline::ProgrammableStageDescriptor {
+            module: shader_module,
+            entry_point,
+            constants,
+            zero_initialize_workgroup_memory: true,
+        },
+    };
+
+    let implicit_pipelines = match layout {
+        CanvasGPUPipelineLayoutOrGPUAutoLayoutMode::Layout(_) => None,
+        CanvasGPUPipelineLayoutOrGPUAutoLayoutMode::Auto(CanvasGPUAutoLayoutMode::Auto) => {
+            Some(wgpu_core::device::ImplicitPipelineIds {
+                root_id: None,
+                group_ids: &[None; MAX_BIND_GROUPS],
+            })
+        }
+    };
+
+    let (pipeline, error) = gfx_select!(device_id => global.device_create_compute_pipeline(device_id, &desc, None, implicit_pipelines));
+
+    let error_sink = device.error_sink.as_ref();
+
+    if let Some(cause) = error {
+        if let wgpu_core::pipeline::CreateComputePipelineError::Internal(ref error) = cause {
+            log::warn!(
+                "Shader translation error for stage {:?}: {}",
+                wgpu_types::ShaderStages::COMPUTE,
+                error
+            );
+            log::warn!("Please report it to https://github.com/gfx-rs/wgpu");
+        }
+
+
+        handle_error(
+            global,
+            error_sink,
+            cause,
+            "label",
+            desc.label,
+            "canvas_native_webgpu_device_create_compute_pipeline",
+        );
+    }
+
+    Arc::into_raw(
+        Arc::new(
+            CanvasGPUComputePipeline {
+                instance: device.instance.clone(),
+                pipeline,
+                error_sink: device.error_sink.clone(),
+            }
+        )
+    )
+}
+
+
+#[no_mangle]
+pub unsafe extern "C" fn canvas_native_webgpu_device_create_compute_pipeline_async(
+    device: *const CanvasGPUDevice,
+    label: *const c_char,
+    layout: CanvasGPUPipelineLayoutOrGPUAutoLayoutMode,
+    compute: *const CanvasProgrammableStage,
+    callback: unsafe extern "C" fn(*const CanvasGPUComputePipeline, super::error::CanvasGPUErrorType, *mut c_char, *mut c_void),
+    callback_data: *mut c_void,
+) {
+    if device.is_null() || compute.is_null() {
+        let error = CString::new("invalid device").unwrap();
+        callback(std::ptr::null(), CanvasGPUErrorType::Internal, error.into_raw(), callback_data);
+        return;
+    }
+
+    let device = &*device;
+    let device_id = device.device;
+
+    let global = device.instance.global();
+
+    let label = ptr_into_label(label);
+
+
+    let pipeline_layout = match layout {
+        CanvasGPUPipelineLayoutOrGPUAutoLayoutMode::Layout(layout) => {
+            let layout = &*layout;
+            Some(layout.layout)
+        }
+        CanvasGPUPipelineLayoutOrGPUAutoLayoutMode::Auto(CanvasGPUAutoLayoutMode::Auto) => None,
+    };
+
+    let compute = &*compute;
+
+    let entry_point = if compute.entry_point.is_null() {
+        None
+    } else {
+        Some(CStr::from_ptr(compute.entry_point).to_string_lossy())
+    };
+
+
+    let constants = if compute.constants.is_null() {
+        let constants = HashMap::default();
+        Cow::Owned(constants)
+    } else {
+        let constants = &*compute.constants;
+        Cow::Borrowed(&constants.0)
+    };
+
+    let module = &*compute.module;
+    let shader_module = module.module;
+
+    let desc = wgpu_core::pipeline::ComputePipelineDescriptor {
+        label,
+        layout: pipeline_layout,
+        stage: wgpu_core::pipeline::ProgrammableStageDescriptor {
+            module: shader_module,
+            entry_point,
+            constants,
+            zero_initialize_workgroup_memory: true,
+        },
+    };
+
+    let implicit_pipelines = match layout {
+        CanvasGPUPipelineLayoutOrGPUAutoLayoutMode::Layout(_) => None,
+        CanvasGPUPipelineLayoutOrGPUAutoLayoutMode::Auto(CanvasGPUAutoLayoutMode::Auto) => {
+            Some(wgpu_core::device::ImplicitPipelineIds {
+                root_id: None,
+                group_ids: &[None; MAX_BIND_GROUPS],
+            })
+        }
+    };
+    let callback = callback as i64;
+    let callback_data = callback_data as i64;
+
+    let instance = device.instance.clone();
+    let error_sink = device.error_sink.clone();
+
+    std::thread::spawn(move || {
+        let (pipeline, error) = gfx_select!(device_id => global.device_create_compute_pipeline(device_id, &desc, None, implicit_pipelines));
+
+        let callback = unsafe {
+            std::mem::transmute::<*const i64, extern "C" fn(*const CanvasGPUComputePipeline, super::error::CanvasGPUErrorType, *mut c_char, *mut c_void)>(
+                callback as _,
+            )
+        };
+
+        let callback_data = callback_data as *mut c_void;
+
+        if let Some(error) = error {
+            let error: CanvasGPUError = error.into();
+            let error_type = match &error {
+                CanvasGPUError::Lost => {
+                    super::error::CanvasGPUErrorType::Lost
+                }
+                CanvasGPUError::OutOfMemory => {
+                    super::error::CanvasGPUErrorType::OutOfMemory
+                }
+                CanvasGPUError::Validation(_) => {
+                    super::error::CanvasGPUErrorType::Validation
+                }
+                CanvasGPUError::Internal => {
+                    super::error::CanvasGPUErrorType::Internal
+                }
+                CanvasGPUError::None => {
+                    CanvasGPUErrorType::None
+                }
+            };
+
+            let error_value = match error {
+                CanvasGPUError::Lost => {
+                    std::ptr::null_mut()
+                }
+                CanvasGPUError::OutOfMemory => {
+                    std::ptr::null_mut()
+                }
+                CanvasGPUError::Validation(value) => {
+                    CString::new(value).unwrap().into_raw()
+                }
+                CanvasGPUError::Internal => {
+                    std::ptr::null_mut()
+                }
+                CanvasGPUError::None => {
+                    std::ptr::null_mut()
+                }
+            };
+            callback(std::ptr::null(), error_type, error_value, callback_data);
+        } else {
+            let ret = Arc::into_raw(
+                Arc::new(
+                    CanvasGPUComputePipeline {
+                        instance,
+                        pipeline,
+                        error_sink,
+                    }
+                )
+            );
+
+            callback(ret, CanvasGPUErrorType::None, std::ptr::null_mut(), callback_data);
+        }
+    });
+}
+
+
+#[no_mangle]
+pub unsafe extern "C" fn canvas_native_webgpu_device_create_pipeline_layout(
+    device: *const CanvasGPUDevice,
+    label: *const c_char,
+    group_layouts: *const CanvasGPUBindGroupLayout,
+    size: usize,
+) -> *const CanvasGPUPipelineLayout {
+    if device.is_null() || group_layouts.is_null() || size == 0 {
+        return std::ptr::null_mut();
+    }
+    let label = ptr_into_label(label);
+
+    let device = &*device;
+
+    let global = device.instance.global();
+
+    let device_id = device.device;
+
+    let group_layouts = std::slice::from_raw_parts(group_layouts, size);
+
+    let group_layouts = group_layouts.iter()
+        .map(|group| {
+            let group = &*group;
+            group.group_layout
+        })
+        .collect::<Vec<_>>();
+
+    let desc = wgpu_core::binding_model::PipelineLayoutDescriptor {
+        label,
+        bind_group_layouts: Cow::Owned(group_layouts),
+        push_constant_ranges: Default::default(),
+    };
+
+    let (pipeline_layout, error) = gfx_select!(device_id => global.device_create_pipeline_layout(device_id, &desc, None));
+
+    let error_sink = device.error_sink.as_ref();
+    if let Some(cause) = error {
+        handle_error(
+            global,
+            error_sink,
+            cause,
+            "label",
+            desc.label,
+            "canvas_native_webgpu_device_create_pipeline_layout",
+        );
+    }
+
+    Arc::into_raw(
+        Arc::new(
+            CanvasGPUPipelineLayout { instance: device.instance.clone(), layout: pipeline_layout }
+        )
+    )
+}
+
+
+#[no_mangle]
+pub unsafe extern "C" fn canvas_native_webgpu_device_create_query_set(
+    device: *const CanvasGPUDevice,
+    label: *const c_char,
+    type_: CanvasQueryType,
+    count: u32,
+) -> *const CanvasGPUQuerySet {
+    if device.is_null() {
+        return std::ptr::null_mut();
+    }
+    let label = ptr_into_label(label);
+
+    let device = &*device;
+
+    let global = device.instance.global();
+
+    let device_id = device.device;
+
+
+    let desc = wgpu_types::QuerySetDescriptor {
+        label,
+        ty: type_.into(),
+        count,
+    };
+
+    let (query, error) = gfx_select!(device_id => global.device_create_query_set(device_id, &desc, None));
+
+    let error_sink = device.error_sink.as_ref();
+    if let Some(cause) = error {
+        handle_error(
+            global,
+            error_sink,
+            cause,
+            "label",
+            desc.label,
+            "canvas_native_webgpu_device_create_query_set",
+        );
+    }
+
+    Arc::into_raw(
+        Arc::new(
+            CanvasGPUQuerySet {
+                instance: device.instance.clone(),
+                query,
+            }
+        )
+    )
+}
+
+
+#[repr(C)]
+pub struct CanvasCreateRenderBundleEncoderDescriptor {
+    label: *const c_char,
+    color_formats: *const CanvasGPUTextureFormat,
+    color_formats_size: usize,
+    depth_stencil_format: *const CanvasGPUTextureFormat,
+    sample_count: u32,
+    depth_read_only: bool,
+    stencil_read_only: bool,
+}
+
+
+#[no_mangle]
+pub unsafe extern "C" fn canvas_native_webgpu_device_create_render_bundle_encoder(
+    device: *const CanvasGPUDevice,
+    descriptor: *const CanvasCreateRenderBundleEncoderDescriptor,
+) -> *const CanvasGPURenderBundleEncoder {
+    if device.is_null() || descriptor.is_null() {
+        return std::ptr::null_mut();
+    }
+
+    let descriptor = &*descriptor;
+
+    let label = ptr_into_label(descriptor.label);
+
+    let device = &*device;
+
+    let global = device.instance.global();
+
+    let device_id = device.device;
+
+
+    let depth_stencil = if !descriptor.depth_stencil_format.is_null() {
+        let format = *descriptor.depth_stencil_format;
+        Some(
+            wgpu_types::RenderBundleDepthStencil {
+                format: format.into(),
+                depth_read_only: descriptor.depth_read_only,
+                stencil_read_only: descriptor.stencil_read_only,
+            }
+        )
+    } else {
+        None
+    };
+
+    let color_formats = if !descriptor.color_formats.is_null() && descriptor.color_formats_size > 0 {
+        unsafe {
+            std::slice::from_raw_parts(descriptor.color_formats, descriptor.color_formats_size)
+                .to_vec()
+                .into_iter()
+                .map(|v| Some(v.into()))
+                .collect::<Vec<_>>()
+        }
+    } else {
+        vec![]
+    };
+
+    let desc = wgpu_core::command::RenderBundleEncoderDescriptor {
+        label,
+        color_formats: Cow::Owned(color_formats),
+        depth_stencil,
+        sample_count: descriptor.sample_count,
+        multiview: None,
+    };
+
+
+    let bundle = wgpu_core::command::RenderBundleEncoder::new(&desc, device_id, None);
 
-    // todo handle error
-    if let Some(error) = error {
-        println!("canvas_native_webgpu_device_create_command_encoder: error {:?}", error.to_string());
-        std::ptr::null_mut()
-    } else {
-        let encoder = CanvasGPUCommandEncoder {
-            instance: device.instance.clone(),
-            encoder,
-        };
-        Box::into_raw(Box::new(encoder))
+    match bundle {
+        Ok(bundle) => {
+            Arc::into_raw(
+                Arc::new(
+                    CanvasGPURenderBundleEncoder {
+                        instance: device.instance.clone(),
+                        encoder: bundle,
+                    }
+                )
+            )
+        }
+        Err(cause) => {
+            handle_error_fatal(global, cause, "canvas_native_webgpu_device_create_render_bundle_encoder");
+            Arc::into_raw(
+                Arc::new(
+                    CanvasGPURenderBundleEncoder {
+                        instance: device.instance.clone(),
+                        encoder: RenderBundleEncoder::dummy(device_id),
+                    }
+                )
+            )
+        }
     }
 }
 
+
 #[no_mangle]
 pub extern "C" fn canvas_native_webgpu_device_create_shader_module(
     device: *const CanvasGPUDevice,
     label: *const c_char,
     source: *const c_char,
-) -> *mut CanvasGPUShaderModule {
+) -> *const CanvasGPUShaderModule {
     if device.is_null() {
         return std::ptr::null_mut();
     }
-    let label = if !label.is_null() {
-        Some(unsafe { CStr::from_ptr(label).to_string_lossy() })
-    } else {
-        None
-    };
+    let label = ptr_into_label(label);
+
     let src = unsafe { CStr::from_ptr(source) };
     let src = src.to_string_lossy();
     let source = wgpu_core::pipeline::ShaderModuleSource::Wgsl(src);
 
     let device = unsafe { &*device };
     let desc = wgpu_core::pipeline::ShaderModuleDescriptor {
-        label: label,
+        label,
         shader_bound_checks: wgpu_types::ShaderBoundChecks::default(),
     };
 
     let device_id = device.device;
-    let global = &device.instance.0;
+    let global = &device.instance.global();
 
     let (module, error) = gfx_select!(device_id => global.device_create_shader_module(device_id, &desc, source, None));
 
-    // todo handle error
-    if let Some(error) = error {
-        std::ptr::null_mut()
-    } else {
-        let shader = CanvasGPUShaderModule {
-            module,
-            instance: device.instance.clone(),
-        };
-        Box::into_raw(Box::new(shader))
+    if let Some(cause) = error {
+        handle_error(
+            global,
+            device.error_sink.as_ref(),
+            cause,
+            "label",
+            desc.label,
+            "canvas_native_webgpu_device_create_shader_module",
+        );
     }
+
+    let shader = CanvasGPUShaderModule {
+        module,
+        instance: device.instance.clone(),
+    };
+    Arc::into_raw(Arc::new(shader))
 }
 
 #[no_mangle]
@@ -289,15 +1080,14 @@ pub extern "C" fn canvas_native_webgpu_device_create_buffer(
     size: u64,
     usage: u32,
     mapped_at_creation: bool,
-    mut error: *mut c_char,
-) -> *mut CanvasGPUBuffer {
+) -> *const CanvasGPUBuffer {
     if device.is_null() {
         return std::ptr::null_mut();
     }
 
     let device = unsafe { &*device };
 
-    device.create_buffer(label, size, usage, mapped_at_creation, error)
+    device.create_buffer(label, size, usage, mapped_at_creation)
 }
 
 pub struct CanvasConstants(HashMap<String, f64>);
@@ -445,7 +1235,7 @@ pub struct CanvasFragmentState {
     pub targets_size: usize,
     pub module: *const CanvasGPUShaderModule,
     pub entry_point: *const c_char,
-    pub  constants: *const CanvasConstants,
+    pub constants: *const CanvasConstants,
 }
 
 #[repr(C)]
@@ -460,22 +1250,21 @@ pub enum CanvasGPUPipelineLayoutOrGPUAutoLayoutMode {
 }
 
 #[repr(C)]
-
 pub struct CanvasCreateRenderPipelineDescriptor {
-    pub  label: *const c_char,
-    pub  layout: CanvasGPUPipelineLayoutOrGPUAutoLayoutMode,
+    pub label: *const c_char,
+    pub layout: CanvasGPUPipelineLayoutOrGPUAutoLayoutMode,
     pub vertex: *const CanvasVertexState,
     pub primitive: *const CanvasPrimitiveState,
     pub depth_stencil: *const CanvasDepthStencilState,
     pub multisample: *const CanvasMultisampleState,
-    pub  fragment: *const CanvasFragmentState,
+    pub fragment: *const CanvasFragmentState,
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_device_create_render_pipeline(
     device: *const CanvasGPUDevice,
     descriptor: *const CanvasCreateRenderPipelineDescriptor,
-) -> *mut CanvasGPURenderPipeline {
+) -> *const CanvasGPURenderPipeline {
     if device.is_null() || descriptor.is_null() {
         return std::ptr::null_mut();
     }
@@ -484,15 +1273,11 @@ pub unsafe extern "C" fn canvas_native_webgpu_device_create_render_pipeline(
 
     let device_id = device.device;
 
-    let global = &device.instance.0;
+    let global = device.instance.global();
 
     let descriptor = &*descriptor;
 
-    let label = if !descriptor.label.is_null() {
-        Some(unsafe { CStr::from_ptr(descriptor.label).to_string_lossy() })
-    } else {
-        None
-    };
+    let label = ptr_into_label(descriptor.label);
 
     let layout = match descriptor.layout {
         CanvasGPUPipelineLayoutOrGPUAutoLayoutMode::Layout(value) => {
@@ -532,12 +1317,12 @@ pub unsafe extern "C" fn canvas_native_webgpu_device_create_render_pipeline(
             vec![]
         };
 
-        if (frag.constants.is_null()) {
+        if frag.constants.is_null() {
             let constants = HashMap::default();
             Some(wgpu_core::pipeline::FragmentState {
                 stage: wgpu_core::pipeline::ProgrammableStageDescriptor {
                     module: module_id,
-                    entry_point: entry_point,
+                    entry_point,
                     constants: Cow::Owned(constants),
                     // Required to be true for WebGPU
                     zero_initialize_workgroup_memory: true,
@@ -550,8 +1335,8 @@ pub unsafe extern "C" fn canvas_native_webgpu_device_create_render_pipeline(
             Some(wgpu_core::pipeline::FragmentState {
                 stage: wgpu_core::pipeline::ProgrammableStageDescriptor {
                     module: module_id,
-                    entry_point: entry_point,
-                    constants: constants,
+                    entry_point,
+                    constants,
                     // Required to be true for WebGPU
                     zero_initialize_workgroup_memory: true,
                 },
@@ -624,8 +1409,8 @@ pub unsafe extern "C" fn canvas_native_webgpu_device_create_render_pipeline(
     let vertex = wgpu_core::pipeline::VertexState {
         stage: wgpu_core::pipeline::ProgrammableStageDescriptor {
             module: vertex_shader_module_id,
-            entry_point: entry_point,
-            constants: constants,
+            entry_point,
+            constants,
             // Required to be true for WebGPU
             zero_initialize_workgroup_memory: true,
         },
@@ -633,13 +1418,13 @@ pub unsafe extern "C" fn canvas_native_webgpu_device_create_render_pipeline(
     };
 
     let desc = wgpu_core::pipeline::RenderPipelineDescriptor {
-        label: label,
-        layout: layout,
-        vertex: vertex,
-        primitive: primitive,
-        depth_stencil: depth_stencil,
-        multisample: multisample,
-        fragment: fragment,
+        label,
+        layout,
+        vertex,
+        primitive,
+        depth_stencil,
+        multisample,
+        fragment,
         multiview: None,
     };
 
@@ -653,19 +1438,283 @@ pub unsafe extern "C" fn canvas_native_webgpu_device_create_render_pipeline(
         }
     };
 
+    let error_sink = device.error_sink.as_ref();
     let (pipeline, error) = gfx_select!(device_id => global.device_create_render_pipeline(device_id, &desc,None, implicit_pipelines));
 
-    if let Some(error) = error {
-        // todo handle error
-        return std::ptr::null_mut();
+    if let Some(cause) = error {
+        if let wgpu_core::pipeline::CreateRenderPipelineError::Internal { stage, ref error } = cause {
+            log::error!("Shader translation error for stage {:?}: {}", stage, error);
+            log::error!("Please report it to https://github.com/gfx-rs/wgpu");
+        }
+        handle_error(
+            global,
+            error_sink,
+            cause,
+            "label",
+            desc.label,
+            "canvas_native_webgpu_device_create_render_pipeline",
+        );
     }
 
-    Box::into_raw(Box::new(CanvasGPURenderPipeline {
+    Arc::into_raw(Arc::new(CanvasGPURenderPipeline {
         instance: device.instance.clone(),
-        pipeline: pipeline,
+        pipeline,
+        error_sink: device.error_sink.clone(),
     }))
 }
 
+
+#[no_mangle]
+pub unsafe extern "C" fn canvas_native_webgpu_device_create_render_pipeline_async(
+    device: *const CanvasGPUDevice,
+    descriptor: *const CanvasCreateRenderPipelineDescriptor,
+    callback: unsafe extern "C" fn(*const CanvasGPURenderPipeline, CanvasGPUErrorType, *mut c_char, *mut c_void),
+    callback_data: *mut c_void,
+) {
+    if device.is_null() || descriptor.is_null() {
+        let error = CString::new("invalid device").unwrap();
+        callback(std::ptr::null(), CanvasGPUErrorType::Internal, error.into_raw(), callback_data);
+        return;
+    }
+
+    let device = unsafe { &*device };
+
+    let device_id = device.device;
+
+    let global = device.instance.global();
+
+    let descriptor = &*descriptor;
+
+    let label = ptr_into_label(descriptor.label);
+
+    let layout = match descriptor.layout {
+        CanvasGPUPipelineLayoutOrGPUAutoLayoutMode::Layout(value) => {
+            if value.is_null() {
+                None
+            } else {
+                let value = &*value;
+                Some(value.layout)
+            }
+        }
+        CanvasGPUPipelineLayoutOrGPUAutoLayoutMode::Auto(CanvasGPUAutoLayoutMode::Auto) => None,
+    };
+
+    let vertex = &*descriptor.vertex;
+
+    let vertex_shader_module = &*vertex.module;
+
+    let vertex_shader_module_id = vertex_shader_module.module;
+
+    let fragment = if !descriptor.fragment.is_null() {
+        let frag = &*descriptor.fragment;
+        let module = &*frag.module;
+        let module_id = module.module;
+
+        let entry_point = if frag.entry_point.is_null() {
+            None
+        } else {
+            Some(CStr::from_ptr(frag.entry_point).to_string_lossy())
+        };
+
+        let targets = if !frag.targets.is_null() {
+            std::slice::from_raw_parts(frag.targets, frag.targets_size)
+                .iter()
+                .map(|target| Some((*target).into()))
+                .collect::<Vec<Option<wgpu_types::ColorTargetState>>>()
+        } else {
+            vec![]
+        };
+
+        if frag.constants.is_null() {
+            let constants = HashMap::default();
+            Some(wgpu_core::pipeline::FragmentState {
+                stage: wgpu_core::pipeline::ProgrammableStageDescriptor {
+                    module: module_id,
+                    entry_point,
+                    constants: Cow::Owned(constants),
+                    // Required to be true for WebGPU
+                    zero_initialize_workgroup_memory: true,
+                },
+                targets: Cow::Owned(targets),
+            })
+        } else {
+            let constants = &*frag.constants;
+            let constants = Cow::Borrowed(&constants.0);
+            Some(wgpu_core::pipeline::FragmentState {
+                stage: wgpu_core::pipeline::ProgrammableStageDescriptor {
+                    module: module_id,
+                    entry_point,
+                    constants,
+                    // Required to be true for WebGPU
+                    zero_initialize_workgroup_memory: true,
+                },
+                targets: Cow::Owned(targets),
+            })
+        }
+    } else {
+        None
+    };
+
+    let primitive: wgpu_types::PrimitiveState = if !descriptor.primitive.is_null() {
+        let primitive = *descriptor.primitive;
+        primitive.into()
+    } else {
+        wgpu_types::PrimitiveState::default()
+    };
+
+    let depth_stencil = if !descriptor.depth_stencil.is_null() {
+        let depth_stencil = *descriptor.depth_stencil;
+        let depth_stencil: wgpu_types::DepthStencilState = depth_stencil.into();
+        Some(depth_stencil)
+    } else {
+        None
+    };
+
+    let multisample: wgpu_types::MultisampleState = if !descriptor.multisample.is_null() {
+        let multisample = *descriptor.multisample;
+        multisample.into()
+    } else {
+        wgpu_types::MultisampleState::default()
+    };
+
+    let vertex_buffers = if !vertex.buffers.is_null() {
+        let buffers = std::slice::from_raw_parts(vertex.buffers, vertex.buffers_size);
+        buffers
+            .iter()
+            .map(|layout| {
+                let attributes = if !layout.attributes.is_null() {
+                    std::slice::from_raw_parts(layout.attributes, layout.attributes_size)
+                        .iter()
+                        .map(|attr| (*attr).into())
+                        .collect::<Vec<wgpu_types::VertexAttribute>>()
+                } else {
+                    vec![]
+                };
+                wgpu_core::pipeline::VertexBufferLayout {
+                    array_stride: layout.array_stride,
+                    attributes: Cow::Owned(attributes),
+                    step_mode: layout.step_mode.into(),
+                }
+            })
+            .collect::<Vec<wgpu_core::pipeline::VertexBufferLayout>>()
+    } else {
+        vec![]
+    };
+
+    let entry_point = if vertex.entry_point.is_null() {
+        None
+    } else {
+        Some(CStr::from_ptr(vertex.entry_point).to_string_lossy())
+    };
+
+    let constants = if !vertex.constants.is_null() {
+        let constants = &*vertex.constants;
+        Cow::Borrowed(&constants.0)
+    } else {
+        Cow::Owned(HashMap::default())
+    };
+
+    let vertex = wgpu_core::pipeline::VertexState {
+        stage: wgpu_core::pipeline::ProgrammableStageDescriptor {
+            module: vertex_shader_module_id,
+            entry_point,
+            constants,
+            // Required to be true for WebGPU
+            zero_initialize_workgroup_memory: true,
+        },
+        buffers: Cow::Owned(vertex_buffers),
+    };
+
+    let desc = wgpu_core::pipeline::RenderPipelineDescriptor {
+        label,
+        layout,
+        vertex,
+        primitive,
+        depth_stencil,
+        multisample,
+        fragment,
+        multiview: None,
+    };
+
+    let implicit_pipelines = match descriptor.layout {
+        CanvasGPUPipelineLayoutOrGPUAutoLayoutMode::Layout(_) => None,
+        CanvasGPUPipelineLayoutOrGPUAutoLayoutMode::Auto(CanvasGPUAutoLayoutMode::Auto) => {
+            Some(wgpu_core::device::ImplicitPipelineIds {
+                root_id: None,
+                group_ids: &[None; MAX_BIND_GROUPS],
+            })
+        }
+    };
+
+    let callback = callback as i64;
+    let callback_data = callback_data as i64;
+
+    let instance = device.instance.clone();
+    let error_sink = device.error_sink.clone();
+
+    std::thread::spawn(move || {
+        let (pipeline, error) = gfx_select!(device_id => global.device_create_render_pipeline(device_id, &desc,None, implicit_pipelines));
+
+
+        let callback = unsafe {
+            std::mem::transmute::<*const i64, extern "C" fn(*const CanvasGPURenderPipeline, CanvasGPUErrorType, *mut c_char, *mut c_void)>(
+                callback as _,
+            )
+        };
+
+        let callback_data = callback_data as *mut c_void;
+
+
+        if let Some(error) = error {
+            let error: CanvasGPUError = error.into();
+            let error_type = match &error {
+                CanvasGPUError::Lost => {
+                    super::error::CanvasGPUErrorType::Lost
+                }
+                CanvasGPUError::OutOfMemory => {
+                    super::error::CanvasGPUErrorType::OutOfMemory
+                }
+                CanvasGPUError::Validation(_) => {
+                    super::error::CanvasGPUErrorType::Validation
+                }
+                CanvasGPUError::Internal => {
+                    super::error::CanvasGPUErrorType::Internal
+                }
+                CanvasGPUError::None => {
+                    CanvasGPUErrorType::None
+                }
+            };
+
+            let error_value = match error {
+                CanvasGPUError::Lost => {
+                    std::ptr::null_mut()
+                }
+                CanvasGPUError::OutOfMemory => {
+                    std::ptr::null_mut()
+                }
+                CanvasGPUError::Validation(value) => {
+                    CString::new(value).unwrap().into_raw()
+                }
+                CanvasGPUError::Internal => {
+                    std::ptr::null_mut()
+                }
+                CanvasGPUError::None => {
+                    std::ptr::null_mut()
+                }
+            };
+            callback(std::ptr::null(), error_type, error_value, callback_data);
+        } else {
+            let ret = Arc::into_raw(Arc::new(CanvasGPURenderPipeline {
+                instance,
+                pipeline,
+                error_sink,
+            }));
+
+            callback(ret, CanvasGPUErrorType::None, std::ptr::null_mut(), callback_data);
+        }
+    });
+}
+
 #[repr(C)]
 pub struct CanvasCreateTextureDescriptor {
     label: *const c_char,
@@ -685,8 +1734,7 @@ pub struct CanvasCreateTextureDescriptor {
 pub extern "C" fn canvas_native_webgpu_device_create_texture(
     device: *const CanvasGPUDevice,
     descriptor: *const CanvasCreateTextureDescriptor,
-    mut error: *mut c_char,
-) -> *mut CanvasGPUTexture {
+) -> *const CanvasGPUTexture {
     if device.is_null() || descriptor.is_null() {
         return std::ptr::null_mut();
     }
@@ -695,13 +1743,9 @@ pub extern "C" fn canvas_native_webgpu_device_create_texture(
     let descriptor = unsafe { &*descriptor };
     let device_id = device.device;
 
-    let global = &device.instance.0;
+    let global = device.instance.global();
 
-    let label = if !descriptor.label.is_null() {
-        Some(unsafe { CStr::from_ptr(descriptor.label).to_string_lossy() })
-    } else {
-        None
-    };
+    let label = ptr_into_label(descriptor.label);
 
     let view_formats = if !descriptor.view_formats.is_null() && descriptor.view_formats_size > 0 {
         unsafe {
@@ -733,13 +1777,18 @@ pub extern "C" fn canvas_native_webgpu_device_create_texture(
     let (texture_id, err) =
         gfx_select!(device_id => global.device_create_texture(device_id, &desc, None));
 
-    if let Some(err) = err {
-        let err = err.to_string();
-        error = CString::new(err).unwrap().into_raw();
-        return std::ptr::null_mut();
+    if let Some(cause) = err {
+        handle_error(
+            global,
+            device.error_sink.as_ref(),
+            cause,
+            "",
+            desc.label,
+            "canvas_native_webgpu_device_create_texture",
+        );
     }
 
-    Box::into_raw(Box::new(CanvasGPUTexture {
+    Arc::into_raw(Arc::new(CanvasGPUTexture {
         instance: device.instance.clone(),
         texture: texture_id,
         owned: true,
@@ -751,5 +1800,82 @@ pub extern "C" fn canvas_native_webgpu_device_create_texture(
         width: descriptor.width,
         height: descriptor.height,
         usage: descriptor.usage,
+        error_sink: device.error_sink.clone(),
     }))
 }
+
+
+#[repr(C)]
+pub struct CanvasCreateSamplerDescriptor {
+    label: *const c_char,
+    address_mode_u: CanvasAddressMode,
+    address_mode_v: CanvasAddressMode,
+    address_mode_w: CanvasAddressMode,
+    mag_filter: CanvasFilterMode,
+    min_filter: CanvasFilterMode,
+    mipmap_filter: CanvasFilterMode, // TODO: GPUMipmapFilterMode
+    lod_min_clamp: f32,
+    lod_max_clamp: f32,
+    compare: CanvasOptionalCompareFunction,
+    max_anisotropy: u16,
+}
+
+
+#[no_mangle]
+pub extern "C" fn canvas_native_webgpu_device_create_sampler(
+    device: *const CanvasGPUDevice,
+    descriptor: *const CanvasCreateSamplerDescriptor,
+) -> *const CanvasGPUSampler {
+    if device.is_null() || descriptor.is_null() {
+        return std::ptr::null_mut();
+    }
+
+    let device = unsafe { &*device };
+    let descriptor = unsafe { &*descriptor };
+    let device_id = device.device;
+
+    let global = device.instance.global();
+
+    let label = ptr_into_label(descriptor.label);
+
+
+    let desc = wgpu_core::resource::SamplerDescriptor {
+        label: label.clone(),
+        address_modes: [
+            descriptor.address_mode_u.into(),
+            descriptor.address_mode_v.into(),
+            descriptor.address_mode_w.into(),
+        ],
+        mag_filter: descriptor.mag_filter.into(),
+        min_filter: descriptor.min_filter.into(),
+        mipmap_filter: descriptor.mipmap_filter.into(),
+        lod_min_clamp: descriptor.lod_min_clamp,
+        lod_max_clamp: descriptor.lod_max_clamp,
+        compare: descriptor.compare.into(),
+        anisotropy_clamp: descriptor.max_anisotropy,
+        border_color: None, // native-only
+    };
+    let (sampler_id, error) = gfx_select!(device_id => global.device_create_sampler(device_id, &desc,None));
+
+    let error_sink = device.error_sink.as_ref();
+    if let Some(cause) = error {
+        handle_error(
+            global,
+            error_sink,
+            cause,
+            "label",
+            desc.label,
+            "canvas_native_webgpu_device_create_sampler",
+        );
+    }
+
+    Arc::into_raw(
+        Arc::new(
+            CanvasGPUSampler {
+                instance: device.instance.clone(),
+                sampler: sampler_id,
+                label,
+            }
+        )
+    )
+}
\ No newline at end of file
diff --git a/crates/canvas-c/src/webgpu/gpu_pipeline_layout.rs b/crates/canvas-c/src/webgpu/gpu_pipeline_layout.rs
index d0ca08bcf..46053646c 100644
--- a/crates/canvas-c/src/webgpu/gpu_pipeline_layout.rs
+++ b/crates/canvas-c/src/webgpu/gpu_pipeline_layout.rs
@@ -1,6 +1,8 @@
+use std::sync::Arc;
+
 use super::gpu::CanvasWebGPUInstance;
 
 pub struct CanvasGPUPipelineLayout {
-    pub(crate) instance: CanvasWebGPUInstance,
+    pub(crate) instance: Arc<CanvasWebGPUInstance>,
     pub(crate) layout: wgpu_core::id::PipelineLayoutId,
 }
diff --git a/crates/canvas-c/src/webgpu/gpu_query_set.rs b/crates/canvas-c/src/webgpu/gpu_query_set.rs
index 21be6b0ae..ef2df7eba 100644
--- a/crates/canvas-c/src/webgpu/gpu_query_set.rs
+++ b/crates/canvas-c/src/webgpu/gpu_query_set.rs
@@ -1,6 +1,8 @@
+use std::sync::Arc;
+
 use super::gpu::CanvasWebGPUInstance;
 
 pub struct CanvasGPUQuerySet {
-    pub(crate) instance: CanvasWebGPUInstance,
+    pub(crate) instance: Arc<CanvasWebGPUInstance>,
     pub(crate) query: wgpu_core::id::QuerySetId,
 }
diff --git a/crates/canvas-c/src/webgpu/gpu_queue.rs b/crates/canvas-c/src/webgpu/gpu_queue.rs
index af63eac2c..229c41f7e 100644
--- a/crates/canvas-c/src/webgpu/gpu_queue.rs
+++ b/crates/canvas-c/src/webgpu/gpu_queue.rs
@@ -1,8 +1,7 @@
-use std::{
-    ffi::CString,
-    os::raw::{c_char, c_void},
-    sync::Arc,
-};
+use std::os::raw::{c_char, c_void};
+use std::sync::Arc;
+
+use crate::webgpu::error::{handle_error, handle_error_fatal};
 
 use super::{
     gpu::CanvasWebGPUInstance,
@@ -14,8 +13,9 @@ use super::{
 
 #[derive(Clone)]
 pub struct CanvasGPUQueue {
-    pub(crate) instance: CanvasWebGPUInstance,
+    pub(crate) instance: Arc<CanvasWebGPUInstance>,
     pub(crate) queue: wgpu_core::id::QueueId,
+    pub(crate) error_sink: super::gpu_device::ErrorSink,
 }
 
 unsafe impl Send for CanvasGPUQueue {}
@@ -44,7 +44,7 @@ fn get_offset_image(
 
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_queue_copy_external_image_to_texture(
-    queue: *mut CanvasGPUQueue,
+    queue: *const CanvasGPUQueue,
     source: *const CanvasImageCopyExternalImage,
     destination: *const CanvasImageCopyTexture,
     size: *const CanvasExtent3d,
@@ -53,10 +53,10 @@ pub unsafe extern "C" fn canvas_native_webgpu_queue_copy_external_image_to_textu
         return;
     }
 
-    let queue = &mut *queue;
+    let queue = &*queue;
     let queue_id = queue.queue;
 
-    let global = &queue.instance.0;
+    let global = queue.instance.global();
 
     let source = &*source;
 
@@ -67,9 +67,6 @@ pub unsafe extern "C" fn canvas_native_webgpu_queue_copy_external_image_to_textu
 
     let destination = &*destination;
 
-    if destination.texture.is_null() {
-        return;
-    }
 
     let destination_texture = &*destination.texture;
 
@@ -112,14 +109,21 @@ pub unsafe extern "C" fn canvas_native_webgpu_queue_copy_external_image_to_textu
         gfx_select!(queue_id =>  global.queue_write_texture(queue_id, &destination, data, &data_layout, &size))
     };
 
-    if let Err(_) = ret {
-        // todo handle error
+    if let Err(cause) = ret {
+        handle_error(
+            global,
+            queue.error_sink.as_ref(),
+            cause,
+            "",
+            None,
+            "canvas_native_webgpu_queue_copy_external_image_to_texture",
+        );
     }
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_queue_on_submitted_work_done(
-    queue: *mut CanvasGPUQueue,
+    queue: *const CanvasGPUQueue,
     callback: extern "C" fn(*mut c_char, *mut c_void),
     callback_data: *mut c_void,
 ) {
@@ -127,10 +131,10 @@ pub unsafe extern "C" fn canvas_native_webgpu_queue_on_submitted_work_done(
         return;
     }
 
-    let queue = &mut *queue;
+    let queue = &*queue;
     let queue_id = queue.queue;
 
-    let global = &queue.instance.0;
+    let global = queue.instance.global();
 
     let func = callback as i64;
     let data = callback_data as i64;
@@ -140,17 +144,15 @@ pub unsafe extern "C" fn canvas_native_webgpu_queue_on_submitted_work_done(
         callback(std::ptr::null_mut(), callback_data);
     }));
 
-    if let Err(error) = gfx_select!(queue_id => global.queue_on_submitted_work_done(queue_id, done))
+    if let Err(cause) = gfx_select!(queue_id => global.queue_on_submitted_work_done(queue_id, done))
     {
-        let error = error.to_string();
-        let error = CString::new(error).unwrap().into_raw();
-        callback(error, callback_data);
+        handle_error_fatal(global, cause, "canvas_native_webgpu_queue_on_submitted_work_done");
     }
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_queue_submit(
-    queue: *mut CanvasGPUQueue,
+    queue: *const CanvasGPUQueue,
     command_buffers: *const *const CanvasGPUCommandBuffer,
     command_buffers_size: usize,
 ) {
@@ -158,10 +160,10 @@ pub unsafe extern "C" fn canvas_native_webgpu_queue_submit(
         return;
     }
 
-    let queue = &mut *queue;
+    let queue = &*queue;
     let queue_id = queue.queue;
 
-    let global = &queue.instance.0;
+    let global = queue.instance.global();
 
     let command_buffer_ids = std::slice::from_raw_parts(command_buffers, command_buffers_size)
         .iter()
@@ -171,22 +173,15 @@ pub unsafe extern "C" fn canvas_native_webgpu_queue_submit(
         })
         .collect::<Vec<wgpu_core::id::CommandBufferId>>();
 
-    match gfx_select!(queue_id => global.queue_submit(queue_id, command_buffer_ids.as_slice())) {
-        Ok(sub) => {
-            // noop ??
-            println!("canvas_native_webgpu_queue_submit : sub index {:?}", sub);
-        }
-        Err(err) => {
-            println!("canvas_native_webgpu_queue_submit : error {:?}", err.to_string());
-            // todo
-        }
+    if let Err(cause) = gfx_select!(queue_id => global.queue_submit(queue_id, command_buffer_ids.as_slice())) {
+        handle_error_fatal(global, cause, "canvas_native_webgpu_queue_submit");
     }
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_queue_write_buffer(
-    queue: *mut CanvasGPUQueue,
-    buffer: *mut CanvasGPUBuffer,
+    queue: *const CanvasGPUQueue,
+    buffer: *const CanvasGPUBuffer,
     buffer_offset: u64,
     data: *const u8,
     data_size: usize,
@@ -197,10 +192,10 @@ pub unsafe extern "C" fn canvas_native_webgpu_queue_write_buffer(
         return;
     }
 
-    let queue = &mut *queue;
+    let queue = &*queue;
     let queue_id = queue.queue;
 
-    let global = &queue.instance.0;
+    let global = queue.instance.global();
 
     let buffer = &*buffer;
     let buffer_id = buffer.buffer;
@@ -214,15 +209,15 @@ pub unsafe extern "C" fn canvas_native_webgpu_queue_write_buffer(
         None => &data[data_offset..],
     };
 
-    if let Err(_) = gfx_select!(queue_id =>  global.queue_write_buffer(queue_id, buffer_id, buffer_offset, data))
+    if let Err(cause) = gfx_select!(queue_id =>  global.queue_write_buffer(queue_id, buffer_id, buffer_offset, data))
     {
-        // todo handle error
+        handle_error(global, queue.error_sink.as_ref(), cause, "", None, "canvas_native_webgpu_queue_write_buffer");
     }
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_queue_write_texture(
-    queue: *mut CanvasGPUQueue,
+    queue: *const CanvasGPUQueue,
     destination: *const CanvasImageCopyTexture,
     data_layout: *const CanvasImageDataLayout,
     size: *const CanvasExtent3d,
@@ -233,15 +228,13 @@ pub unsafe extern "C" fn canvas_native_webgpu_queue_write_texture(
         return;
     }
 
-    let queue = &mut *queue;
+    let queue = &*queue;
     let queue_id = queue.queue;
 
-    let global = &queue.instance.0;
+    let global = queue.instance.global();
 
     let destination = &*destination;
-    if destination.texture.is_null() {
-        return;
-    }
+
     let destination_texture = &*destination.texture;
     let destination_texture_id = destination_texture.texture;
 
@@ -262,8 +255,15 @@ pub unsafe extern "C" fn canvas_native_webgpu_queue_write_texture(
 
     let size: wgpu_types::Extent3d = size.into();
 
-    if let Err(_) = gfx_select!(queue_id =>  global.queue_write_texture(queue_id, &destination, data, &data_layout, &size))
+    if let Err(cause) = gfx_select!(queue_id =>  global.queue_write_texture(queue_id, &destination, data, &data_layout, &size))
     {
-        // todo handle error
+        handle_error(
+            global,
+            queue.error_sink.as_ref(),
+            cause,
+            "",
+            None,
+            "canvas_native_webgpu_queue_write_texture",
+        );
     }
 }
diff --git a/crates/canvas-c/src/webgpu/gpu_render_bundle.rs b/crates/canvas-c/src/webgpu/gpu_render_bundle.rs
index d3bb455e1..a76c28d13 100644
--- a/crates/canvas-c/src/webgpu/gpu_render_bundle.rs
+++ b/crates/canvas-c/src/webgpu/gpu_render_bundle.rs
@@ -1,6 +1,8 @@
+use std::sync::Arc;
+
 use super::gpu::CanvasWebGPUInstance;
 
 pub struct CanvasGPURenderBundle {
-    pub(crate) instance: CanvasWebGPUInstance,
-    pub(crate) bundle: wgpu_core::id::RenderBundleId
+    pub(crate) instance: Arc<CanvasWebGPUInstance>,
+    pub(crate) bundle: wgpu_core::id::RenderBundleId,
 }
\ No newline at end of file
diff --git a/crates/canvas-c/src/webgpu/gpu_render_bundle_encoder.rs b/crates/canvas-c/src/webgpu/gpu_render_bundle_encoder.rs
new file mode 100644
index 000000000..8c2fa4c3c
--- /dev/null
+++ b/crates/canvas-c/src/webgpu/gpu_render_bundle_encoder.rs
@@ -0,0 +1,8 @@
+use std::sync::Arc;
+
+use crate::webgpu::gpu::CanvasWebGPUInstance;
+
+pub struct CanvasGPURenderBundleEncoder {
+    pub(crate) instance: Arc<CanvasWebGPUInstance>,
+    pub(crate) encoder: wgpu_core::command::RenderBundleEncoder,
+}
diff --git a/crates/canvas-c/src/webgpu/gpu_render_pass.rs b/crates/canvas-c/src/webgpu/gpu_render_pass_encoder.rs
similarity index 68%
rename from crates/canvas-c/src/webgpu/gpu_render_pass.rs
rename to crates/canvas-c/src/webgpu/gpu_render_pass_encoder.rs
index f3a21666c..69eb79e05 100644
--- a/crates/canvas-c/src/webgpu/gpu_render_pass.rs
+++ b/crates/canvas-c/src/webgpu/gpu_render_pass_encoder.rs
@@ -1,28 +1,46 @@
-use std::{ffi::CStr, num::NonZeroU64, os::raw::c_char};
+use std::{ffi::CStr, os::raw::c_char};
+use std::borrow::Cow;
+use std::sync::Arc;
 
+use crate::webgpu::error::handle_error;
+use crate::webgpu::gpu_compute_pass_encoder::CanvasGPUComputePassEncoder;
 use super::{
     enums::CanvasIndexFormat, gpu::CanvasWebGPUInstance, gpu_bind_group::CanvasGPUBindGroup,
-    gpu_buffer::CanvasGPUBuffer, gpu_command_encoder::CanvasGPUCommandEncoder,
-    gpu_query_set::CanvasGPUQuerySet, gpu_render_bundle::CanvasGPURenderBundle,
+    gpu_buffer::CanvasGPUBuffer
+    , gpu_render_bundle::CanvasGPURenderBundle,
     gpu_render_pipeline::CanvasGPURenderPipeline, structs::CanvasColor,
 };
 
-pub struct CanvasGPURenderPass {
-    pub(crate) instance: CanvasWebGPUInstance,
-    pub(crate) pass: wgpu_core::command::RenderPass,
+pub struct CanvasGPURenderPassEncoder {
+    pub(crate) label: Option<Cow<'static, str>>,
+    pub(crate) instance: Arc<CanvasWebGPUInstance>,
+    pub(crate) pass: *mut wgpu_core::command::RenderPass,
+    pub(crate) error_sink: super::gpu_device::ErrorSink,
 }
 
+
+impl Drop for CanvasGPURenderPassEncoder {
+    fn drop(&mut self) {
+        if !std::thread::panicking() {
+            drop(unsafe { Box::from_raw(self.pass) });
+        }
+    }
+}
+// CanvasGPURenderPassEncoder is thread-unsafe
+unsafe impl Send for CanvasGPURenderPassEncoder {}
+unsafe impl Sync for CanvasGPURenderPassEncoder {}
+
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_render_pass_begin_occlusion_query(
-    render_pass: *mut CanvasGPURenderPass,
+    render_pass: *const CanvasGPURenderPassEncoder,
     query_index: u32,
 ) {
     if render_pass.is_null() {
         return;
     }
 
-    let render_pass = &mut *render_pass;
-    let render_pass = &mut render_pass.pass;
+    let render_pass = &*render_pass;
+    let render_pass = &mut *render_pass.pass;
 
     wgpu_core::command::render_commands::wgpu_render_pass_begin_occlusion_query(
         render_pass,
@@ -32,7 +50,7 @@ pub unsafe extern "C" fn canvas_native_webgpu_render_pass_begin_occlusion_query(
 
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_render_pass_encoder_draw(
-    render_pass: *mut CanvasGPURenderPass,
+    render_pass: *const CanvasGPURenderPassEncoder,
     vertex_count: u32,
     instance_count: u32,
     first_vertex: u32,
@@ -42,11 +60,9 @@ pub unsafe extern "C" fn canvas_native_webgpu_render_pass_encoder_draw(
         return;
     }
 
-    let render_pass = &mut *render_pass;
-
-    let global = &mut render_pass.instance.0;
+    let render_pass = &*render_pass;
 
-    let pass = &mut render_pass.pass;
+    let pass = &mut* render_pass.pass;
 
     wgpu_core::command::render_commands::wgpu_render_pass_draw(
         pass,
@@ -59,7 +75,7 @@ pub unsafe extern "C" fn canvas_native_webgpu_render_pass_encoder_draw(
 
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_render_pass_draw_indexed(
-    render_pass: *mut CanvasGPURenderPass,
+    render_pass: *const CanvasGPURenderPassEncoder,
     index_count: u32,
     instance_count: u32,
     first_index: u32,
@@ -70,11 +86,9 @@ pub unsafe extern "C" fn canvas_native_webgpu_render_pass_draw_indexed(
         return;
     }
 
-    let render_pass = &mut *render_pass;
+    let render_pass = &*render_pass;
 
-    let global = &mut render_pass.instance.0;
-
-    let pass = &mut render_pass.pass;
+    let pass = &mut* render_pass.pass;
 
     wgpu_core::command::render_commands::wgpu_render_pass_draw_indexed(
         pass,
@@ -88,23 +102,21 @@ pub unsafe extern "C" fn canvas_native_webgpu_render_pass_draw_indexed(
 
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_render_pass_draw_indexed_indirect(
-    render_pass: *mut CanvasGPURenderPass,
-    indirect_buffer: *mut CanvasGPUBuffer,
+    render_pass: *const CanvasGPURenderPassEncoder,
+    indirect_buffer: *const CanvasGPUBuffer,
     indirect_offset: u64,
 ) {
     if render_pass.is_null() || indirect_buffer.is_null() {
         return;
     }
 
-    let render_pass = &mut *render_pass;
+    let render_pass = &*render_pass;
 
-    let indirect_buffer = &mut *indirect_buffer;
+    let indirect_buffer = &*indirect_buffer;
 
     let buffer_id = indirect_buffer.buffer;
 
-    let global = &mut render_pass.instance.0;
-
-    let pass = &mut render_pass.pass;
+    let pass = &mut* render_pass.pass;
 
     wgpu_core::command::render_commands::wgpu_render_pass_draw_indexed_indirect(
         pass,
@@ -115,23 +127,20 @@ pub unsafe extern "C" fn canvas_native_webgpu_render_pass_draw_indexed_indirect(
 
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_render_pass_draw_indirect(
-    render_pass: *mut CanvasGPURenderPass,
-    indirect_buffer: *mut CanvasGPUBuffer,
+    render_pass: *const CanvasGPURenderPassEncoder,
+    indirect_buffer: *const CanvasGPUBuffer,
     indirect_offset: u64,
 ) {
     if render_pass.is_null() || indirect_buffer.is_null() {
         return;
     }
 
-    let render_pass = &mut *render_pass;
+    let render_pass = &*render_pass;
 
-    let indirect_buffer = &mut *indirect_buffer;
+    let indirect_buffer = &*indirect_buffer;
 
     let buffer_id = indirect_buffer.buffer;
-
-    let global = &mut render_pass.instance.0;
-
-    let pass = &mut render_pass.pass;
+    let pass = &mut* render_pass.pass;
 
     wgpu_core::command::render_commands::wgpu_render_pass_draw_indirect(
         pass,
@@ -142,43 +151,50 @@ pub unsafe extern "C" fn canvas_native_webgpu_render_pass_draw_indirect(
 
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_render_pass_end(
-    render_pass: *mut CanvasGPURenderPass,
+    render_pass: *const CanvasGPURenderPassEncoder,
 ) {
     if render_pass.is_null() {
         return;
     }
 
-    let render_pass = &mut *render_pass;
+    let render_pass = &*render_pass;
 
-    let global = &mut render_pass.instance.0;
+    let global = render_pass.instance.global();
 
-    let pass = &mut render_pass.pass;
+    let pass = &mut* render_pass.pass;
 
     let command_encoder = pass.parent_id();
 
-    if let Err(_) = gfx_select!(command_encoder => global.command_encoder_run_render_pass(command_encoder, pass))
+    if let Err(cause) = gfx_select!(command_encoder => global.command_encoder_run_render_pass(command_encoder, pass))
     {
-        // todo
+        handle_error(
+            global,
+            render_pass.error_sink.as_ref(),
+            cause,
+            "encoder",
+            render_pass.label.clone(),
+            "canvas_native_webgpu_render_pass_end",
+        );
     }
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_render_pass_end_occlusion_query(
-    render_pass: *mut CanvasGPURenderPass,
+    render_pass: *const CanvasGPURenderPassEncoder,
 ) {
     if render_pass.is_null() {
         return;
     }
 
-    let render_pass = &mut *render_pass;
-    let render_pass = &mut render_pass.pass;
+    let render_pass = &*render_pass;
+    let render_pass = &mut *render_pass.pass;
 
     wgpu_core::command::render_commands::wgpu_render_pass_end_occlusion_query(render_pass);
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_render_pass_execute_bundles(
-    render_pass: *mut CanvasGPURenderPass,
+    render_pass: *const CanvasGPURenderPassEncoder,
     bundles: *const CanvasGPURenderBundle,
     bundles_size: usize,
 ) {
@@ -186,8 +202,8 @@ pub unsafe extern "C" fn canvas_native_webgpu_render_pass_execute_bundles(
         return;
     }
 
-    let render_pass = &mut *render_pass;
-    let render_pass = &mut render_pass.pass;
+    let render_pass = &*render_pass;
+    let render_pass = &mut *render_pass.pass;
 
     let bundles = std::slice::from_raw_parts(bundles, bundles_size)
         .iter()
@@ -202,15 +218,15 @@ pub unsafe extern "C" fn canvas_native_webgpu_render_pass_execute_bundles(
 
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_render_pass_insert_debug_marker(
-    render_pass: *mut CanvasGPURenderPass,
+    render_pass: *const CanvasGPURenderPassEncoder,
     label: *const c_char,
 ) {
     if render_pass.is_null() || label.is_null() {
         return;
     }
 
-    let render_pass = &mut *render_pass;
-    let render_pass = &mut render_pass.pass;
+    let render_pass = &*render_pass;
+    let render_pass = &mut *render_pass.pass;
 
     let label = CStr::from_ptr(label);
     let label = label.to_string_lossy();
@@ -224,29 +240,29 @@ pub unsafe extern "C" fn canvas_native_webgpu_render_pass_insert_debug_marker(
 
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_render_pass_pop_debug_group(
-    render_pass: *mut CanvasGPURenderPass,
+    render_pass: *const CanvasGPURenderPassEncoder,
 ) {
     if render_pass.is_null() {
         return;
     }
 
-    let render_pass = &mut *render_pass;
-    let render_pass = &mut render_pass.pass;
+    let render_pass = &*render_pass;
+    let render_pass = &mut *render_pass.pass;
 
     wgpu_core::command::render_commands::wgpu_render_pass_pop_debug_group(render_pass);
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_render_pass_push_debug_group(
-    render_pass: *mut CanvasGPURenderPass,
+    render_pass: *const CanvasGPURenderPassEncoder,
     label: *const c_char,
 ) {
     if render_pass.is_null() || label.is_null() {
         return;
     }
 
-    let render_pass = &mut *render_pass;
-    let render_pass = &mut render_pass.pass;
+    let render_pass = &*render_pass;
+    let render_pass = &mut *render_pass.pass;
 
     let label = CStr::from_ptr(label);
     let label = label.to_string_lossy();
@@ -260,7 +276,7 @@ pub unsafe extern "C" fn canvas_native_webgpu_render_pass_push_debug_group(
 
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_render_pass_set_bind_group(
-    render_pass: *mut CanvasGPURenderPass,
+    render_pass: *const CanvasGPURenderPassEncoder,
     index: u32,
     bind_group: *const CanvasGPUBindGroup,
     dynamic_offsets: *const u32,
@@ -272,8 +288,8 @@ pub unsafe extern "C" fn canvas_native_webgpu_render_pass_set_bind_group(
         return;
     }
 
-    let render_pass = &mut *render_pass;
-    let render_pass = &mut render_pass.pass;
+    let render_pass = &*render_pass;
+    let render_pass = &mut *render_pass.pass;
 
     let bind_group = &*bind_group;
     let bind_group_id = bind_group.group;
@@ -308,15 +324,15 @@ pub unsafe extern "C" fn canvas_native_webgpu_render_pass_set_bind_group(
 
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_render_pass_set_blend_constant(
-    render_pass: *mut CanvasGPURenderPass,
+    render_pass: *const CanvasGPURenderPassEncoder,
     color: *const CanvasColor,
 ) {
     if render_pass.is_null() || color.is_null() {
         return;
     }
 
-    let render_pass = &mut *render_pass;
-    let render_pass = &mut render_pass.pass;
+    let render_pass = &*render_pass;
+    let render_pass = &mut *render_pass.pass;
 
     let color: wgpu_types::Color = (*color).into();
 
@@ -328,7 +344,7 @@ pub unsafe extern "C" fn canvas_native_webgpu_render_pass_set_blend_constant(
 
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_render_pass_set_index_buffer(
-    render_pass: *mut CanvasGPURenderPass,
+    render_pass: *const CanvasGPURenderPassEncoder,
     buffer: *const CanvasGPUBuffer,
     index_format: CanvasIndexFormat,
     offset: i64,
@@ -338,14 +354,14 @@ pub unsafe extern "C" fn canvas_native_webgpu_render_pass_set_index_buffer(
         return;
     }
 
-    let render_pass = &mut *render_pass;
-    let render_pass = &mut render_pass.pass;
+    let render_pass = &*render_pass;
+    let render_pass = &mut *render_pass.pass;
 
     let buffer = &*buffer;
     let buffer_id = buffer.buffer;
 
     let offset: u64 = offset.try_into().unwrap_or_default();
-  
+
     let size: Option<u64> = size.try_into().ok();
 
     let mut sizeValue: Option<std::num::NonZero<u64>> = None;
@@ -379,15 +395,15 @@ pub unsafe extern "C" fn canvas_native_webgpu_render_pass_set_index_buffer(
 
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_render_pass_set_pipeline(
-    render_pass: *mut CanvasGPURenderPass,
+    render_pass: *const CanvasGPURenderPassEncoder,
     pipeline: *const CanvasGPURenderPipeline,
 ) {
     if render_pass.is_null() || pipeline.is_null() {
         return;
     }
 
-    let render_pass = &mut *render_pass;
-    let render_pass = &mut render_pass.pass;
+    let render_pass = &*render_pass;
+    let render_pass = &mut *render_pass.pass;
 
     let pipeline = &*pipeline;
     let pipeline_id = pipeline.pipeline;
@@ -397,7 +413,7 @@ pub unsafe extern "C" fn canvas_native_webgpu_render_pass_set_pipeline(
 
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_render_pass_set_scissor_rect(
-    render_pass: *mut CanvasGPURenderPass,
+    render_pass: *const CanvasGPURenderPassEncoder,
     x: u32,
     y: u32,
     width: u32,
@@ -407,8 +423,8 @@ pub unsafe extern "C" fn canvas_native_webgpu_render_pass_set_scissor_rect(
         return;
     }
 
-    let render_pass = &mut *render_pass;
-    let render_pass = &mut render_pass.pass;
+    let render_pass = &*render_pass;
+    let render_pass = &mut *render_pass.pass;
 
     wgpu_core::command::render_commands::wgpu_render_pass_set_scissor_rect(
         render_pass,
@@ -421,15 +437,15 @@ pub unsafe extern "C" fn canvas_native_webgpu_render_pass_set_scissor_rect(
 
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_render_pass_set_stencil_reference(
-    render_pass: *mut CanvasGPURenderPass,
+    render_pass: *const CanvasGPURenderPassEncoder,
     reference: u32,
 ) {
     if render_pass.is_null() {
         return;
     }
 
-    let render_pass = &mut *render_pass;
-    let render_pass = &mut render_pass.pass;
+    let render_pass = &*render_pass;
+    let render_pass = &mut *render_pass.pass;
 
     wgpu_core::command::render_commands::wgpu_render_pass_set_stencil_reference(
         render_pass,
@@ -439,9 +455,9 @@ pub unsafe extern "C" fn canvas_native_webgpu_render_pass_set_stencil_reference(
 
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_render_pass_set_vertex_buffer(
-    render_pass: *mut CanvasGPURenderPass,
+    render_pass: *const CanvasGPURenderPassEncoder,
     slot: u32,
-    buffer: *mut CanvasGPUBuffer,
+    buffer: *const CanvasGPUBuffer,
     offset: i64,
     size: i64,
 ) {
@@ -449,8 +465,8 @@ pub unsafe extern "C" fn canvas_native_webgpu_render_pass_set_vertex_buffer(
         return;
     }
 
-    let render_pass = &mut *render_pass;
-    let render_pass = &mut render_pass.pass;
+    let render_pass = &*render_pass;
+    let render_pass = &mut *render_pass.pass;
 
     let buffer = &*buffer;
     let buffer_id = buffer.buffer;
@@ -461,9 +477,8 @@ pub unsafe extern "C" fn canvas_native_webgpu_render_pass_set_vertex_buffer(
 
     if let Some(value) = size {
         sizeValue = std::num::NonZero::new(value);
-    }else {
+    } else {
         sizeValue = std::num::NonZero::new(buffer.size);
-        println!("SIZE {}", buffer.size);
     }
 
     if size.is_some() {
@@ -491,7 +506,7 @@ pub unsafe extern "C" fn canvas_native_webgpu_render_pass_set_vertex_buffer(
 
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_render_pass_set_viewport(
-    render_pass: *mut CanvasGPURenderPass,
+    render_pass: *const CanvasGPURenderPassEncoder,
     x: f32,
     y: f32,
     width: f32,
@@ -503,8 +518,8 @@ pub unsafe extern "C" fn canvas_native_webgpu_render_pass_set_viewport(
         return;
     }
 
-    let render_pass = &mut *render_pass;
-    let render_pass = &mut render_pass.pass;
+    let render_pass = &*render_pass;
+    let render_pass = &mut *render_pass.pass;
 
     wgpu_core::command::render_commands::wgpu_render_pass_set_viewport(
         render_pass,
@@ -516,3 +531,25 @@ pub unsafe extern "C" fn canvas_native_webgpu_render_pass_set_viewport(
         depth_max,
     );
 }
+
+
+
+#[no_mangle]
+pub unsafe extern "C" fn canvas_native_webgpu_render_pass_reference(
+    render_pass: *const CanvasGPURenderPassEncoder
+) {
+    if render_pass.is_null() {
+        return;
+    }
+    Arc::increment_strong_count(render_pass);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn canvas_native_webgpu_render_pass_release(
+    render_pass: *const CanvasGPURenderPassEncoder
+) {
+    if render_pass.is_null() {
+        return;
+    }
+    Arc::decrement_strong_count(render_pass);
+}
\ No newline at end of file
diff --git a/crates/canvas-c/src/webgpu/gpu_render_pipeline.rs b/crates/canvas-c/src/webgpu/gpu_render_pipeline.rs
index bba04486a..35e5c1d36 100644
--- a/crates/canvas-c/src/webgpu/gpu_render_pipeline.rs
+++ b/crates/canvas-c/src/webgpu/gpu_render_pipeline.rs
@@ -1,15 +1,20 @@
+use std::sync::Arc;
+
+use crate::webgpu::error::handle_error;
+
 use super::{gpu::CanvasWebGPUInstance, gpu_bind_group_layout::CanvasGPUBindGroupLayout};
 
 pub struct CanvasGPURenderPipeline {
-    pub(crate) instance: CanvasWebGPUInstance,
+    pub(crate) instance: Arc<CanvasWebGPUInstance>,
     pub(crate) pipeline: wgpu_core::id::RenderPipelineId,
+    pub(crate) error_sink: super::gpu_device::ErrorSink,
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_render_pipeline_get_bind_group_layout(
     pipeline: *const CanvasGPURenderPipeline,
     index: u32,
-)-> *mut CanvasGPUBindGroupLayout {
+) -> *const CanvasGPUBindGroupLayout {
     if pipeline.is_null() {
         return std::ptr::null_mut();
     }
@@ -17,17 +22,23 @@ pub unsafe extern "C" fn canvas_native_webgpu_render_pipeline_get_bind_group_lay
     let pipeline = &*pipeline;
     let pipeline_id = pipeline.pipeline;
 
-    let global = &pipeline.instance.0;
+    let global = pipeline.instance.global();
 
     let (group_layout, error) = gfx_select!(pipeline_id => global.render_pipeline_get_bind_group_layout(pipeline_id, index, None));
 
-    if let Some(error) = error {
-        // todo handle error
-        return std::ptr::null_mut();
+    if let Some(cause) = error {
+        handle_error(
+            global,
+            pipeline.error_sink.as_ref(),
+            cause,
+            "",
+            None,
+            "canvas_native_webgpu_render_pipeline_get_bind_group_layout",
+        );
     }
 
-    Box::into_raw(Box::new(CanvasGPUBindGroupLayout {
+    Arc::into_raw(Arc::new(CanvasGPUBindGroupLayout {
         instance: pipeline.instance.clone(),
-        group_layout: group_layout,
+        group_layout,
     }))
 }
diff --git a/crates/canvas-c/src/webgpu/gpu_sampler.rs b/crates/canvas-c/src/webgpu/gpu_sampler.rs
new file mode 100644
index 000000000..0d867fcd0
--- /dev/null
+++ b/crates/canvas-c/src/webgpu/gpu_sampler.rs
@@ -0,0 +1,10 @@
+use std::borrow::Cow;
+use std::sync::Arc;
+
+use crate::webgpu::gpu::CanvasWebGPUInstance;
+
+pub struct CanvasGPUSampler {
+    pub(crate) instance: Arc<CanvasWebGPUInstance>,
+    pub(crate) sampler: wgpu_core::id::SamplerId,
+    pub(crate) label: Option<Cow<'static, str>>,
+}
diff --git a/crates/canvas-c/src/webgpu/gpu_shader_module.rs b/crates/canvas-c/src/webgpu/gpu_shader_module.rs
index f082f65d2..d43154bc1 100644
--- a/crates/canvas-c/src/webgpu/gpu_shader_module.rs
+++ b/crates/canvas-c/src/webgpu/gpu_shader_module.rs
@@ -1,13 +1,13 @@
+use std::sync::Arc;
+
 use super::gpu::CanvasWebGPUInstance;
 
 pub struct CanvasGPUShaderModule {
-    pub(crate) instance: CanvasWebGPUInstance,
+    pub(crate) instance: Arc<CanvasWebGPUInstance>,
     pub(crate) module: wgpu_core::id::ShaderModuleId,
 }
 
 
-
-
 // #[no_mangle]
 // pub extern "C" fn canvas_native_webgpu_device_create_shader_module_get_compilation_info(
 //     shader_module: *const CanvasGPUShaderModule,
diff --git a/crates/canvas-c/src/webgpu/gpu_supported_limits.rs b/crates/canvas-c/src/webgpu/gpu_supported_limits.rs
index d1fd437f9..e06d5bcae 100644
--- a/crates/canvas-c/src/webgpu/gpu_supported_limits.rs
+++ b/crates/canvas-c/src/webgpu/gpu_supported_limits.rs
@@ -134,10 +134,13 @@ pub extern "C" fn canvas_native_webgpu_create_limits() -> *mut CanvasGPUSupporte
     Box::into_raw(Box::new(wgpu_types::Limits::default().into()))
 }
 
+
 #[no_mangle]
-pub extern "C" fn canvas_native_webgpu_limits_destroy(limits: *mut CanvasGPUSupportedLimits) {
+pub unsafe extern "C" fn canvas_native_webgpu_limits_release(limits: *mut CanvasGPUSupportedLimits) {
     if limits.is_null() {
         return;
     }
-    let _ = unsafe { Box::from_raw(limits) };
+
+    // Arc::decrement_strong_count(limits);
+    let _ = Box::from_raw(limits);
 }
diff --git a/crates/canvas-c/src/webgpu/gpu_texture.rs b/crates/canvas-c/src/webgpu/gpu_texture.rs
index 148a46d1b..91f287dd7 100644
--- a/crates/canvas-c/src/webgpu/gpu_texture.rs
+++ b/crates/canvas-c/src/webgpu/gpu_texture.rs
@@ -1,11 +1,12 @@
-use std::{
-    ffi::{CStr, CString},
-    os::raw::c_char,
-};
+use std::os::raw::c_char;
+use std::sync::Arc;
+
+use crate::webgpu::error::handle_error;
+use crate::webgpu::prelude::ptr_into_label;
 
 use super::{
     enums::{
-        CanvasGPUTextureFormat, CanvasOptionalTextureDimension, CanvasOptionalTextureViewDimension,
+        CanvasGPUTextureFormat, CanvasOptionalTextureViewDimension,
         CanvasOptionsGPUTextureFormat, CanvasTextureDimension,
     },
     gpu::CanvasWebGPUInstance,
@@ -15,7 +16,7 @@ use super::{
 
 #[derive(Clone)]
 pub struct CanvasGPUTexture {
-    pub(crate) instance: CanvasWebGPUInstance,
+    pub(crate) instance: Arc<CanvasWebGPUInstance>,
     pub(crate) texture: wgpu_core::id::TextureId,
     pub(crate) owned: bool,
     pub(crate) depth_or_array_layers: u32,
@@ -26,6 +27,7 @@ pub struct CanvasGPUTexture {
     pub(crate) width: u32,
     pub(crate) height: u32,
     pub(crate) usage: u32,
+    pub(crate) error_sink: super::gpu_device::ErrorSink,
 }
 
 #[repr(C)]
@@ -37,33 +39,42 @@ pub struct CanvasCreateTextureViewDescriptor {
     range: *const CanvasImageSubresourceRange,
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn canvas_native_webgpu_texture_reference(texture: *const CanvasGPUTexture) {
+    if texture.is_null() { return; }
+    Arc::increment_strong_count(texture);
+}
+
+
+#[no_mangle]
+pub unsafe extern "C" fn canvas_native_webgpu_texture_release(texture: *const CanvasGPUTexture) {
+    if texture.is_null() { return; }
+    Arc::decrement_strong_count(texture);
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn canvas_native_webgpu_texture_create_texture_view(
-    texture: *mut CanvasGPUTexture,
+    texture: *const CanvasGPUTexture,
     descriptor: *const CanvasCreateTextureViewDescriptor,
-) -> *mut CanvasGPUTextureView {
+) -> *const CanvasGPUTextureView {
     if texture.is_null() {
         return std::ptr::null_mut();
     }
     let texture = unsafe { &*texture };
     let texture_id = texture.texture;
-    let global = &texture.instance.0;
+    let global = texture.instance.global();
 
-   let desc = if descriptor.is_null() {
+    let desc = if descriptor.is_null() {
         wgpu_core::resource::TextureViewDescriptor::default()
     } else {
         let descriptor = &*descriptor;
 
-        let label = if !descriptor.label.is_null() {
-            Some(unsafe { CStr::from_ptr(descriptor.label).to_string_lossy() })
-        } else {
-            None
-        };
+        let label = ptr_into_label(descriptor.label);
 
         let range = *descriptor.range;
 
         wgpu_core::resource::TextureViewDescriptor {
-            label: label,
+            label,
             format: descriptor.format.into(),
             dimension: descriptor.dimension.into(),
             range: range.into(),
@@ -73,20 +84,28 @@ pub unsafe extern "C" fn canvas_native_webgpu_texture_create_texture_view(
     let (texture_view, error) =
         gfx_select!(texture_id => global.texture_create_view(texture_id, &desc, None));
 
-    if let Some(error) = error {
-        // todo handle error
-        return std::ptr::null_mut();
+    let error_sink = texture.error_sink.as_ref();
+
+    if let Some(cause) = error {
+        handle_error(
+            global,
+            error_sink,
+            cause,
+            "",
+            None,
+            "canvas_native_webgpu_texture_create_texture_view",
+        );
     }
 
-    Box::into_raw(Box::new(CanvasGPUTextureView {
+    Arc::into_raw(Arc::new(CanvasGPUTextureView {
         instance: texture.instance.clone(),
-        texture_view: texture_view,
+        texture_view,
     }))
 }
 
 #[no_mangle]
 pub extern "C" fn canvas_native_webgpu_texture_get_depth_or_array_layers(
-    texture: *mut CanvasGPUTexture,
+    texture: *const CanvasGPUTexture,
 ) -> u32 {
     if texture.is_null() {
         return 0;
@@ -96,7 +115,7 @@ pub extern "C" fn canvas_native_webgpu_texture_get_depth_or_array_layers(
 }
 
 #[no_mangle]
-pub extern "C" fn canvas_native_webgpu_texture_get_width(texture: *mut CanvasGPUTexture) -> u32 {
+pub extern "C" fn canvas_native_webgpu_texture_get_width(texture: *const CanvasGPUTexture) -> u32 {
     if texture.is_null() {
         return 0;
     }
@@ -105,7 +124,7 @@ pub extern "C" fn canvas_native_webgpu_texture_get_width(texture: *mut CanvasGPU
 }
 
 #[no_mangle]
-pub extern "C" fn canvas_native_webgpu_texture_get_height(texture: *mut CanvasGPUTexture) -> u32 {
+pub extern "C" fn canvas_native_webgpu_texture_get_height(texture: *const CanvasGPUTexture) -> u32 {
     if texture.is_null() {
         return 0;
     }
@@ -115,7 +134,7 @@ pub extern "C" fn canvas_native_webgpu_texture_get_height(texture: *mut CanvasGP
 
 #[no_mangle]
 pub extern "C" fn canvas_native_webgpu_texture_get_dimension(
-    texture: *mut CanvasGPUTexture,
+    texture: *const CanvasGPUTexture,
 ) -> CanvasTextureDimension {
     if texture.is_null() {
         return CanvasTextureDimension::D2;
@@ -126,7 +145,7 @@ pub extern "C" fn canvas_native_webgpu_texture_get_dimension(
 
 #[no_mangle]
 pub extern "C" fn canvas_native_webgpu_texture_get_format(
-    texture: *mut CanvasGPUTexture,
+    texture: *const CanvasGPUTexture,
 ) -> CanvasGPUTextureFormat {
     if texture.is_null() {
         #[cfg(any(target_os = "ios", target_os = "macos"))]
@@ -140,7 +159,7 @@ pub extern "C" fn canvas_native_webgpu_texture_get_format(
 }
 
 #[no_mangle]
-pub extern "C" fn canvas_native_webgpu_texture_get_usage(texture: *mut CanvasGPUTexture) -> u32 {
+pub extern "C" fn canvas_native_webgpu_texture_get_usage(texture: *const CanvasGPUTexture) -> u32 {
     if texture.is_null() {
         return 0;
     }
@@ -150,7 +169,7 @@ pub extern "C" fn canvas_native_webgpu_texture_get_usage(texture: *mut CanvasGPU
 
 #[no_mangle]
 pub extern "C" fn canvas_native_webgpu_texture_get_label(
-    texture: *mut CanvasGPUTexture,
+    _texture: *const CanvasGPUTexture,
 ) -> *mut c_char {
     // todo
     std::ptr::null_mut()
@@ -158,7 +177,7 @@ pub extern "C" fn canvas_native_webgpu_texture_get_label(
 
 #[no_mangle]
 pub extern "C" fn canvas_native_webgpu_texture_get_mip_level_count(
-    texture: *mut CanvasGPUTexture,
+    texture: *const CanvasGPUTexture,
 ) -> u32 {
     if texture.is_null() {
         return 0;
@@ -169,7 +188,7 @@ pub extern "C" fn canvas_native_webgpu_texture_get_mip_level_count(
 
 #[no_mangle]
 pub extern "C" fn canvas_native_webgpu_texture_get_sample_count(
-    texture: *mut CanvasGPUTexture,
+    texture: *const CanvasGPUTexture,
 ) -> u32 {
     if texture.is_null() {
         return 0;
@@ -180,20 +199,14 @@ pub extern "C" fn canvas_native_webgpu_texture_get_sample_count(
 
 #[no_mangle]
 pub extern "C" fn canvas_native_webgpu_texture_destroy(
-    texture: *mut CanvasGPUTexture,
-) -> *mut c_char {
+    texture: *const CanvasGPUTexture,
+) {
     if texture.is_null() {
-        return std::ptr::null_mut();
+        return;
     }
     let texture = unsafe { &*texture };
     let texture_id = texture.texture;
-    let global = &texture.instance.0;
+    let global = texture.instance.global();
 
-    match gfx_select!(texture_id => global.texture_destroy(texture_id)) {
-        Ok(_) => std::ptr::null_mut(),
-        Err(err) => {
-            let err = err.to_string();
-            CString::new(err).unwrap().into_raw()
-        }
-    }
+    let _ = gfx_select!(texture_id => global.texture_destroy(texture_id));
 }
diff --git a/crates/canvas-c/src/webgpu/gpu_texture_view.rs b/crates/canvas-c/src/webgpu/gpu_texture_view.rs
index 1e5403a9c..5dbddf8ce 100644
--- a/crates/canvas-c/src/webgpu/gpu_texture_view.rs
+++ b/crates/canvas-c/src/webgpu/gpu_texture_view.rs
@@ -1,7 +1,41 @@
+use std::sync::Arc;
+
 use super::gpu::CanvasWebGPUInstance;
 
 #[derive(Clone)]
 pub struct CanvasGPUTextureView {
-    pub(crate) instance: CanvasWebGPUInstance,
+    pub(crate) instance: Arc<CanvasWebGPUInstance>,
     pub(crate) texture_view: wgpu_core::id::TextureViewId,
 }
+
+
+impl Drop for CanvasGPUTextureView {
+    fn drop(&mut self) {
+        if !std::thread::panicking() {
+            let global = self.instance.global();
+            gfx_select!(texture => global.texture_view_drop(self.texture_view, false));
+        }
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn canvas_native_webgpu_texture_view_reference(
+    texture_view: *const CanvasGPUTextureView
+) {
+    if texture_view.is_null() {
+        return;
+    }
+
+    Arc::increment_strong_count(texture_view);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn canvas_native_webgpu_texture_view_release(
+    texture_view: *const CanvasGPUTextureView
+) {
+    if texture_view.is_null() {
+        return;
+    }
+
+    Arc::decrement_strong_count(texture_view);
+}
\ No newline at end of file
diff --git a/crates/canvas-c/src/webgpu/mod.rs b/crates/canvas-c/src/webgpu/mod.rs
index 6a12b1aa1..0918ad91b 100644
--- a/crates/canvas-c/src/webgpu/mod.rs
+++ b/crates/canvas-c/src/webgpu/mod.rs
@@ -1,9 +1,9 @@
 pub use wgpu_core;
 pub use wgpu_types;
 
-
 #[macro_use]
 mod macros {
+    #[cfg(any(target_os = "ios", target_os = "macos"))]
     macro_rules! gfx_select {
         ($id:expr => $p0:ident.$p1:tt.$method:ident $params:tt) => {
           gfx_select!($id => {$p0.$p1}, $method $params)
@@ -14,25 +14,40 @@ mod macros {
         };
 
         ($id:expr => {$($c:tt)*}, $method:ident $params:tt) => {
-          $($c)*.$method::<wgpu_core::api::Metal> $params
+            $($c)*.$method::<wgpu_core::api::Metal> $params
         };
       }
-}
 
 
+    #[cfg(any(target_os = "android"))]
+    macro_rules! gfx_select {
+        ($id:expr => $p0:ident.$p1:tt.$method:ident $params:tt) => {
+          gfx_select!($id => {$p0.$p1}, $method $params)
+        };
+
+        ($id:expr => $p0:ident.$method:ident $params:tt) => {
+          gfx_select!($id => {$p0}, $method $params)
+        };
+
+        ($id:expr => {$($c:tt)*}, $method:ident $params:tt) => {
+             $($c)*.$method::<wgpu_core::api::Vulkan> $params
+        };
+      }
+}
+
 
 pub mod gpu;
 pub mod gpu_adapter_info;
 pub mod gpu_adapter;
 pub mod gpu_buffer;
 pub mod gpu_command_encoder;
-pub mod gpu_compute_pass;
+pub mod gpu_compute_pass_encoder;
 pub mod gpu_device;
 pub mod gpu_query_set;
 pub mod gpu_queue;
 pub mod gpu_supported_limits;
 pub mod prelude;
-pub mod gpu_render_pass;
+pub mod gpu_render_pass_encoder;
 pub mod gpu_shader_module;
 pub mod gpu_canvas_context;
 pub mod enums;
@@ -44,4 +59,8 @@ pub mod gpu_command_buffer;
 pub mod structs;
 pub mod gpu_render_bundle;
 pub mod gpu_render_pipeline;
-pub mod gpu_pipeline_layout;
\ No newline at end of file
+pub mod gpu_pipeline_layout;
+mod error;
+mod gpu_compute_pipeline;
+mod gpu_sampler;
+mod gpu_render_bundle_encoder;
\ No newline at end of file
diff --git a/crates/canvas-c/src/webgpu/prelude.rs b/crates/canvas-c/src/webgpu/prelude.rs
index f1599ba79..8f9dbca30 100644
--- a/crates/canvas-c/src/webgpu/prelude.rs
+++ b/crates/canvas-c/src/webgpu/prelude.rs
@@ -1,4 +1,15 @@
 use std::{ffi::CStr, os::raw::c_char};
+use std::borrow::Cow;
+
+#[inline]
+pub(crate) fn ptr_into_label<'a>(ptr: *const std::ffi::c_char) -> wgpu_core::Label<'a> {
+    unsafe { ptr.as_ref() }.and_then(|ptr| {
+        unsafe { CStr::from_ptr(ptr) }
+            .to_str()
+            .ok()
+            .map(Cow::Borrowed)
+    })
+}
 
 pub fn build_features(features: wgpu_types::Features) -> Vec<&'static str> {
     let mut return_features: Vec<&'static str> = vec![];
@@ -236,16 +247,16 @@ pub fn parse_required_features(
 
                 "sampled-texture-and-storage-buffer-array-non-uniform-indexing" => {
                     features.set(
-                            wgpu_types::Features::SAMPLED_TEXTURE_AND_STORAGE_BUFFER_ARRAY_NON_UNIFORM_INDEXING,
-                            true,
-                        );
+                        wgpu_types::Features::SAMPLED_TEXTURE_AND_STORAGE_BUFFER_ARRAY_NON_UNIFORM_INDEXING,
+                        true,
+                    );
                 }
 
                 "uniform-buffer-and-storage-texture-array-non-uniform-indexing" => {
                     features.set(
-                            wgpu_types::Features::UNIFORM_BUFFER_AND_STORAGE_TEXTURE_ARRAY_NON_UNIFORM_INDEXING,
-                            true,
-                        );
+                        wgpu_types::Features::UNIFORM_BUFFER_AND_STORAGE_TEXTURE_ARRAY_NON_UNIFORM_INDEXING,
+                        true,
+                    );
                 }
 
                 "partially-bound-binding-array" => {
diff --git a/crates/canvas-c/src/webgpu/structs.rs b/crates/canvas-c/src/webgpu/structs.rs
index 5aaf9207a..e7e865e9a 100644
--- a/crates/canvas-c/src/webgpu/structs.rs
+++ b/crates/canvas-c/src/webgpu/structs.rs
@@ -1,5 +1,3 @@
-use wgpu_core::naga::valid;
-
 use super::{
     enums::{CanvasGPUTextureFormat, CanvasTextureAspect, CanvasVertexFormat},
     gpu_texture_view::CanvasGPUTextureView,
diff --git a/crates/playground/src/main.rs b/crates/playground/src/main.rs
index a7180bcd0..22ad21ac8 100644
--- a/crates/playground/src/main.rs
+++ b/crates/playground/src/main.rs
@@ -921,16 +921,16 @@ fn main() {
                 let render_pass = unsafe { canvas_c::webgpu::gpu_command_encoder::canvas_native_webgpu_command_encoder_begin_render_pass(command_encoder, std::ptr::null(), color_attachments.as_ptr(), color_attachments.len(), std::ptr::null(), std::ptr::null(), std::ptr::null(), -1, -1)};
 
 
-                unsafe { canvas_c::webgpu::gpu_render_pass::canvas_native_webgpu_render_pass_set_pipeline(render_pass, pipeline) }
+                unsafe { canvas_c::webgpu::gpu_render_pass_encoder::canvas_native_webgpu_render_pass_set_pipeline(render_pass, pipeline) }
 
             
-                unsafe { canvas_c::webgpu::gpu_render_pass::canvas_native_webgpu_render_pass_set_vertex_buffer(render_pass, 0, buffer, 0, -1) }
+                unsafe { canvas_c::webgpu::gpu_render_pass_encoder::canvas_native_webgpu_render_pass_set_vertex_buffer(render_pass, 0, buffer, 0, -1) }
 
 
-                unsafe { canvas_c::webgpu::gpu_render_pass::canvas_native_webgpu_render_pass_encoder_draw(render_pass, 3, 1, 0,0) }
+                unsafe { canvas_c::webgpu::gpu_render_pass_encoder::canvas_native_webgpu_render_pass_encoder_draw(render_pass, 3, 1, 0, 0) }
 
 
-                unsafe { canvas_c::webgpu::gpu_render_pass::canvas_native_webgpu_render_pass_end(render_pass) }
+                unsafe { canvas_c::webgpu::gpu_render_pass_encoder::canvas_native_webgpu_render_pass_end(render_pass) }
 
 
                 let exe = unsafe {canvas_c::webgpu::gpu_command_encoder::canvas_native_webgpu_command_encoder_finish(command_encoder, std::ptr::null()) };
diff --git a/packages/canvas-media/platforms/android/canvas_media.aar b/packages/canvas-media/platforms/android/canvas_media.aar
index 02d6124cf..1c25b22cb 100644
Binary files a/packages/canvas-media/platforms/android/canvas_media.aar and b/packages/canvas-media/platforms/android/canvas_media.aar differ
diff --git a/packages/canvas-polyfill/platforms/android/canvas_polyfill.aar b/packages/canvas-polyfill/platforms/android/canvas_polyfill.aar
index 63be105db..f6e081d36 100644
Binary files a/packages/canvas-polyfill/platforms/android/canvas_polyfill.aar and b/packages/canvas-polyfill/platforms/android/canvas_polyfill.aar differ
diff --git a/packages/canvas/WebGPU/GPUCanvasContext.ts b/packages/canvas/WebGPU/GPUCanvasContext.ts
index 3e0806430..9444be1d6 100644
--- a/packages/canvas/WebGPU/GPUCanvasContext.ts
+++ b/packages/canvas/WebGPU/GPUCanvasContext.ts
@@ -2,7 +2,7 @@ import { Helpers } from '../helpers';
 import { contextPtr_, native_ } from './Constants';
 import { GPUDevice } from './GPUDevice';
 import { GPUTexture } from './GPUTexture';
-
+import { GPUAdapter } from './GPUAdapter';
 export class GPUCanvasContext {
 	_type;
 	static {
@@ -64,4 +64,12 @@ export class GPUCanvasContext {
 
 		return null;
 	}
+
+	presentSurface() {
+		this[native_].presentSurface();
+	}
+
+	capabilities(adapter: GPUAdapter) {
+		return this[native_].capabilities(adapter[native_]);
+	}
 }
diff --git a/packages/canvas/WebGPU/GPUCommandEncoder.ts b/packages/canvas/WebGPU/GPUCommandEncoder.ts
index eff070aef..30ace6a69 100644
--- a/packages/canvas/WebGPU/GPUCommandEncoder.ts
+++ b/packages/canvas/WebGPU/GPUCommandEncoder.ts
@@ -15,13 +15,23 @@ export class GPUCommandEncoder {
 	}
 
 	beginRenderPass(desc) {
+		desc.colorAttachments = desc.colorAttachments.map((attachment) => {
+			if (Array.isArray(attachment.clearValue)) {
+				attachment.clearValue = { r: attachment.clearValue[0], g: attachment.clearValue[1], b: attachment.clearValue[2], a: attachment.clearValue[3] };
+			}
+			attachment.view = attachment.view[native_];
+			return attachment;
+		});
+
+		if (desc?.depthStencilAttachment?.view?.[native_]) {
+			desc.depthStencilAttachment.view = desc.depthStencilAttachment.view[native_];
+		}
 		const passEncoder = this[native_].beginRenderPass(desc);
 		return GPURenderPassEncoder.fromNative(passEncoder);
 	}
 
 	finish(descriptor?: { label?: string }) {
 		const ret = this[native_].finish(descriptor);
-		console.log('finish', ret);
 		return GPUCommandBuffer.fromNative(ret);
 	}
 }
diff --git a/packages/canvas/WebGPU/GPUDevice.ts b/packages/canvas/WebGPU/GPUDevice.ts
index b7d5ce0ed..4c33d0925 100644
--- a/packages/canvas/WebGPU/GPUDevice.ts
+++ b/packages/canvas/WebGPU/GPUDevice.ts
@@ -168,18 +168,41 @@ export class GPUDevice extends EventTarget {
 	}
 
 	createRenderPipeline(desc) {
+		const vertex = desc['vertex'];
+		vertex.module = vertex.module[native_];
+
+		const buffers = vertex['buffers'];
+		if (Array.isArray(buffers)) {
+			vertex['buffers'] = buffers.map((buffer) => {
+				buffer.attributes = buffer.attributes.map((attr) => {
+					attr['format'] = parseVertexFormat(attr['format']);
+					return attr;
+				});
+				switch (buffer.stepMode) {
+					case 'vertex':
+						buffer.stepMode = 0;
+						break;
+					case 'instance':
+						buffer.stepMode = 1;
+						break;
+				}
+
+				return buffer;
+			});
+		}
+
 		const depthStencil = desc['depthStencil'];
 		if (depthStencil) {
 		}
 		const fragment = desc['fragment'];
 		if (fragment) {
-			fragment.module = fragment?.module?.[native_];
-			console.log(fragment.targets);
+			fragment.module = fragment.module[native_];
 		}
+
 		const layout = desc['layout'];
 
 		if (layout instanceof GPUPipelineLayout) {
-			desc.layout = layout[native_];
+			desc.layout = desc.layout[native_];
 		}
 
 		const multisample = desc['multisample'];
@@ -207,31 +230,6 @@ export class GPUDevice extends EventTarget {
 			}
 		}
 
-		const vertex = desc['vertex'];
-		desc.vertex.module = vertex?.module?.[native_];
-
-		const buffers = vertex['buffers'];
-		if (Array.isArray(buffers)) {
-			vertex['buffers'] = buffers.map((buffer) => {
-				buffer.attributes = buffer.attributes.map((attr) => {
-					attr['format'] = parseVertexFormat(attr['format']);
-					return attr;
-				});
-
-				console.log('is', Array.isArray(buffer.attributes));
-				switch (buffer.stepmode) {
-					case 'vertex':
-						buffer.stepmode = 0;
-						break;
-					case 'instance':
-						buffer.stepmode = 1;
-						break;
-				}
-
-				return buffer;
-			});
-		}
-
 		return GPURenderPipeline.fromNative(this[native_].createRenderPipeline(desc));
 	}
 
diff --git a/packages/canvas/WebGPU/GPUQueue.ts b/packages/canvas/WebGPU/GPUQueue.ts
index e966ec86a..ebb47322a 100644
--- a/packages/canvas/WebGPU/GPUQueue.ts
+++ b/packages/canvas/WebGPU/GPUQueue.ts
@@ -23,6 +23,12 @@ export class GPUQueue {
 	}
 
 	submit(commands: GPUCommandBuffer[]) {
-		console.log('submit', commands);
+		if (Array.isArray(commands)) {
+			this[native_].submit(
+				commands.map((command) => {
+					return command[native_];
+				})
+			);
+		}
 	}
 }
diff --git a/packages/canvas/WebGPU/GPURenderPassEncoder.ts b/packages/canvas/WebGPU/GPURenderPassEncoder.ts
index d21a97288..ce338dcff 100644
--- a/packages/canvas/WebGPU/GPURenderPassEncoder.ts
+++ b/packages/canvas/WebGPU/GPURenderPassEncoder.ts
@@ -19,7 +19,7 @@ export class GPURenderPassEncoder {
 	}
 
 	setVertexBuffer(slot: number, buffer: GPUBuffer, offset?: number, size?: number) {
-		this[native_].setVertexBuffer(slot, buffer[native_], offset, size);
+		this[native_].setVertexBuffer(slot, buffer[native_], offset ?? -1, size ?? -1);
 	}
 
 	draw(vertexCount: number, instanceCount: number = 1, firstVertex: number = 0, firstInstance: number = 0) {
diff --git a/packages/canvas/WebGPU/GPUTexture.ts b/packages/canvas/WebGPU/GPUTexture.ts
index 36c363fe4..6f0d6cb0f 100644
--- a/packages/canvas/WebGPU/GPUTexture.ts
+++ b/packages/canvas/WebGPU/GPUTexture.ts
@@ -39,7 +39,6 @@ export class GPUTexture {
 
 	createView(desc?) {
 		const view = this[native_].createView(desc);
-		console.log('createView', desc, view);
 		return GPUTextureView.fromNative(view);
 	}
 }
diff --git a/packages/canvas/WebGPU/GPUTextureView.ts b/packages/canvas/WebGPU/GPUTextureView.ts
index 07296221b..181c13da1 100644
--- a/packages/canvas/WebGPU/GPUTextureView.ts
+++ b/packages/canvas/WebGPU/GPUTextureView.ts
@@ -3,7 +3,6 @@ import { native_ } from './Constants';
 export class GPUTextureView {
 	[native_];
 	static fromNative(view) {
-		console.log('GPUTextureView', !!view);
 		if (view) {
 			const ret = new GPUTextureView();
 			ret[native_] = view;
diff --git a/packages/canvas/platforms/android/canvas-release.aar b/packages/canvas/platforms/android/canvas-release.aar
index 27914a349..c8859a325 100644
Binary files a/packages/canvas/platforms/android/canvas-release.aar and b/packages/canvas/platforms/android/canvas-release.aar differ
diff --git a/packages/canvas/platforms/ios/CanvasNative.xcframework/Info.plist b/packages/canvas/platforms/ios/CanvasNative.xcframework/Info.plist
index e18dd57e0..d423fbd38 100644
--- a/packages/canvas/platforms/ios/CanvasNative.xcframework/Info.plist
+++ b/packages/canvas/platforms/ios/CanvasNative.xcframework/Info.plist
@@ -10,18 +10,15 @@
 			<key>DebugSymbolsPath</key>
 			<string>dSYMs</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64_x86_64-simulator</string>
+			<string>ios-arm64</string>
 			<key>LibraryPath</key>
 			<string>CanvasNative.framework</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
-				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
-			<key>SupportedPlatformVariant</key>
-			<string>simulator</string>
 		</dict>
 		<dict>
 			<key>BinaryPath</key>
@@ -29,15 +26,18 @@
 			<key>DebugSymbolsPath</key>
 			<string>dSYMs</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64</string>
+			<string>ios-arm64_x86_64-simulator</string>
 			<key>LibraryPath</key>
 			<string>CanvasNative.framework</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
+				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
 		</dict>
 	</array>
 	<key>CFBundlePackageType</key>
diff --git a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/CanvasNative b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/CanvasNative
index 062b590f4..c6793de12 100755
Binary files a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/CanvasNative and b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/CanvasNative differ
diff --git a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/Headers/canvas_native.h b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/Headers/canvas_native.h
index b299e05f8..bdf2fa39e 100644
--- a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/Headers/canvas_native.h
+++ b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/Headers/canvas_native.h
@@ -8,6 +8,38 @@
 #include <stdint.h>
 #include <stdlib.h>
 
+typedef enum CanvasAddressMode {
+  /**
+   * Clamp the value to the edge of the texture
+   *
+   * -0.25 -> 0.0
+   * 1.25  -> 1.0
+   */
+  CanvasAddressModeClampToEdge = 0,
+  /**
+   * Repeat the texture in a tiling fashion
+   *
+   * -0.25 -> 0.75
+   * 1.25 -> 0.25
+   */
+  CanvasAddressModeRepeat = 1,
+  /**
+   * Repeat the texture, mirroring it every repeat
+   *
+   * -0.25 -> 0.25
+   * 1.25 -> 0.75
+   */
+  CanvasAddressModeMirrorRepeat = 2,
+  /**
+   * Clamp the value to the border of the texture
+   * Requires feature [`Features::ADDRESS_MODE_CLAMP_TO_BORDER`]
+   *
+   * -0.25 -> border
+   * 1.25 -> border
+   */
+  CanvasAddressModeClampToBorder = 3,
+} CanvasAddressMode;
+
 /**
  * ASTC block dimensions
  */
@@ -188,6 +220,12 @@ typedef enum CanvasBlendOperation {
   CanvasBlendOperationMax = 4,
 } CanvasBlendOperation;
 
+typedef enum CanvasBufferBindingType {
+  CanvasBufferBindingTypeUniform,
+  CanvasBufferBindingTypeStorage,
+  CanvasBufferBindingTypeReadOnlyStorage,
+} CanvasBufferBindingType;
+
 typedef enum CanvasCompareFunction {
   CanvasCompareFunctionNever = 1,
   CanvasCompareFunctionLess = 2,
@@ -205,6 +243,16 @@ typedef enum CanvasCullMode {
   CanvasCullModeBack,
 } CanvasCullMode;
 
+typedef enum CanvasFilterMode {
+  CanvasFilterModeNearest = 0,
+  /**
+   * Linear Interpolation
+   *
+   * This makes textures smooth but blurry when used as a mag filter.
+   */
+  CanvasFilterModeLinear = 1,
+} CanvasFilterMode;
+
 typedef enum CanvasFrontFace {
   CanvasFrontFaceCcw = 0,
   CanvasFrontFaceCw = 1,
@@ -214,6 +262,14 @@ typedef enum CanvasGPUAutoLayoutMode {
   CanvasGPUAutoLayoutModeAuto,
 } CanvasGPUAutoLayoutMode;
 
+typedef enum CanvasGPUErrorType {
+  CanvasGPUErrorTypeNone,
+  CanvasGPUErrorTypeLost,
+  CanvasGPUErrorTypeOutOfMemory,
+  CanvasGPUErrorTypeValidation,
+  CanvasGPUErrorTypeInternal,
+} CanvasGPUErrorType;
+
 typedef enum CanvasGPUPowerPreference {
   CanvasGPUPowerPreferenceNone,
   CanvasGPUPowerPreferenceLowPower,
@@ -271,6 +327,28 @@ typedef enum CanvasPrimitiveTopology {
   CanvasPrimitiveTopologyTriangleStrip = 4,
 } CanvasPrimitiveTopology;
 
+typedef enum CanvasQueryType {
+  CanvasQueryTypeOcclusion,
+  CanvasQueryTypeTimestamp,
+} CanvasQueryType;
+
+typedef enum CanvasSamplerBindingType {
+  /**
+   * The sampling result is produced based on more than a single color sample from a texture,
+   * e.g. when bilinear interpolation is enabled.
+   */
+  CanvasSamplerBindingTypeFiltering,
+  /**
+   * The sampling result is produced based on a single color sample from a texture.
+   */
+  CanvasSamplerBindingTypeNonFiltering,
+  /**
+   * Use as a comparison sampler instead of a normal sampler.
+   * For more info take a look at the analogous functionality in OpenGL: <https://www.khronos.org/opengl/wiki/Sampler_Object#Comparison_mode>.
+   */
+  CanvasSamplerBindingTypeComparison,
+} CanvasSamplerBindingType;
+
 typedef enum CanvasStencilOperation {
   CanvasStencilOperationKeep = 0,
   CanvasStencilOperationZero = 1,
@@ -282,6 +360,64 @@ typedef enum CanvasStencilOperation {
   CanvasStencilOperationDecrementWrap = 7,
 } CanvasStencilOperation;
 
+typedef enum CanvasStorageTextureAccess {
+  /**
+   * The texture can only be written in the shader and it:
+   * - may or may not be annotated with `write` (WGSL).
+   * - must be annotated with `writeonly` (GLSL).
+   *
+   * Example WGSL syntax:
+   * ```rust,ignore
+   * @group(0) @binding(0)
+   * var my_storage_image: texture_storage_2d<f32, write>;
+   * ```
+   *
+   * Example GLSL syntax:
+   * ```cpp,ignore
+   * layout(set=0, binding=0, r32f) writeonly uniform image2D myStorageImage;
+   * ```
+   */
+  CanvasStorageTextureAccessWriteOnly,
+  /**
+   * The texture can only be read in the shader and it must be annotated with `read` (WGSL) or
+   * `readonly` (GLSL).
+   *
+   * [`Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES`] must be enabled to use this access
+   * mode. This is a native-only extension.
+   *
+   * Example WGSL syntax:
+   * ```rust,ignore
+   * @group(0) @binding(0)
+   * var my_storage_image: texture_storage_2d<f32, read>;
+   * ```
+   *
+   * Example GLSL syntax:
+   * ```cpp,ignore
+   * layout(set=0, binding=0, r32f) readonly uniform image2D myStorageImage;
+   * ```
+   */
+  CanvasStorageTextureAccessReadOnly,
+  /**
+   * The texture can be both read and written in the shader and must be annotated with
+   * `read_write` in WGSL.
+   *
+   * [`Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES`] must be enabled to use this access
+   * mode.  This is a nonstandard, native-only extension.
+   *
+   * Example WGSL syntax:
+   * ```rust,ignore
+   * @group(0) @binding(0)
+   * var my_storage_image: texture_storage_2d<f32, read_write>;
+   * ```
+   *
+   * Example GLSL syntax:
+   * ```cpp,ignore
+   * layout(set=0, binding=0, r32f) uniform image2D myStorageImage;
+   * ```
+   */
+  CanvasStorageTextureAccessReadWrite,
+} CanvasStorageTextureAccess;
+
 typedef enum CanvasStoreOp {
   CanvasStoreOpDiscard = 0,
   CanvasStoreOpStore = 1,
@@ -320,6 +456,23 @@ typedef enum CanvasTextureDimension {
   CanvasTextureDimensionD3,
 } CanvasTextureDimension;
 
+typedef enum CanvasTextureSampleType {
+  CanvasTextureSampleTypeFloat,
+  CanvasTextureSampleTypeUnfilterableFloat,
+  CanvasTextureSampleTypeDepth,
+  CanvasTextureSampleTypeSint,
+  CanvasTextureSampleTypeUint,
+} CanvasTextureSampleType;
+
+typedef enum CanvasTextureViewDimension {
+  CanvasTextureViewDimensionD1,
+  CanvasTextureViewDimensionD2,
+  CanvasTextureViewDimensionD2Array,
+  CanvasTextureViewDimensionCube,
+  CanvasTextureViewDimensionCubeArray,
+  CanvasTextureViewDimensionD3,
+} CanvasTextureViewDimension;
+
 typedef enum CanvasVertexFormat {
   CanvasVertexFormatUint8x2 = 0,
   CanvasVertexFormatUint8x4 = 1,
@@ -478,10 +631,14 @@ typedef struct CanvasGPUCommandBuffer CanvasGPUCommandBuffer;
 
 typedef struct CanvasGPUCommandEncoder CanvasGPUCommandEncoder;
 
-typedef struct CanvasGPUComputePass CanvasGPUComputePass;
+typedef struct CanvasGPUComputePassEncoder CanvasGPUComputePassEncoder;
+
+typedef struct CanvasGPUComputePipeline CanvasGPUComputePipeline;
 
 typedef struct CanvasGPUDevice CanvasGPUDevice;
 
+typedef struct CanvasGPUError CanvasGPUError;
+
 typedef struct CanvasGPUPipelineLayout CanvasGPUPipelineLayout;
 
 typedef struct CanvasGPUQuerySet CanvasGPUQuerySet;
@@ -490,10 +647,14 @@ typedef struct CanvasGPUQueue CanvasGPUQueue;
 
 typedef struct CanvasGPURenderBundle CanvasGPURenderBundle;
 
-typedef struct CanvasGPURenderPass CanvasGPURenderPass;
+typedef struct CanvasGPURenderBundleEncoder CanvasGPURenderBundleEncoder;
+
+typedef struct CanvasGPURenderPassEncoder CanvasGPURenderPassEncoder;
 
 typedef struct CanvasGPURenderPipeline CanvasGPURenderPipeline;
 
+typedef struct CanvasGPUSampler CanvasGPUSampler;
+
 typedef struct CanvasGPUShaderModule CanvasGPUShaderModule;
 
 typedef struct CanvasGPUTexture CanvasGPUTexture;
@@ -726,65 +887,21 @@ typedef struct CanvasExtent3d {
   uint32_t depth_or_array_layers;
 } CanvasExtent3d;
 
-typedef enum CanvasGPUPipelineLayoutOrGPUAutoLayoutMode_Tag {
-  CanvasGPUPipelineLayoutOrGPUAutoLayoutModeLayout,
-  CanvasGPUPipelineLayoutOrGPUAutoLayoutModeAuto,
-} CanvasGPUPipelineLayoutOrGPUAutoLayoutMode_Tag;
+typedef struct CanvasBufferBindingLayout {
+  enum CanvasBufferBindingType type_;
+  bool has_dynamic_offset;
+  int64_t min_binding_size;
+} CanvasBufferBindingLayout;
 
-typedef struct CanvasGPUPipelineLayoutOrGPUAutoLayoutMode {
-  CanvasGPUPipelineLayoutOrGPUAutoLayoutMode_Tag tag;
-  union {
-    struct {
-      const struct CanvasGPUPipelineLayout *layout;
-    };
-    struct {
-      enum CanvasGPUAutoLayoutMode auto_;
-    };
-  };
-} CanvasGPUPipelineLayoutOrGPUAutoLayoutMode;
-
-typedef struct CanvasVertexAttribute {
-  enum CanvasVertexFormat format;
-  uint64_t offset;
-  uint32_t shader_location;
-} CanvasVertexAttribute;
-
-typedef struct CanvasVertexBufferLayout {
-  uint64_t array_stride;
-  enum CanvasVertexStepMode step_mode;
-  const struct CanvasVertexAttribute *attributes;
-  uintptr_t attributes_size;
-} CanvasVertexBufferLayout;
+typedef struct CanvasSamplerBindingLayout {
+  enum CanvasSamplerBindingType type_;
+} CanvasSamplerBindingLayout;
 
-typedef struct CanvasVertexState {
-  const struct CanvasGPUShaderModule *module;
-  const char *entry_point;
-  const struct CanvasConstants *constants;
-  const struct CanvasVertexBufferLayout *buffers;
-  uintptr_t buffers_size;
-} CanvasVertexState;
-
-typedef enum CanvasOptionalIndexFormat_Tag {
-  CanvasOptionalIndexFormatNone,
-  CanvasOptionalIndexFormatSome,
-} CanvasOptionalIndexFormat_Tag;
-
-typedef struct CanvasOptionalIndexFormat {
-  CanvasOptionalIndexFormat_Tag tag;
-  union {
-    struct {
-      enum CanvasIndexFormat some;
-    };
-  };
-} CanvasOptionalIndexFormat;
-
-typedef struct CanvasPrimitiveState {
-  enum CanvasPrimitiveTopology topology;
-  struct CanvasOptionalIndexFormat strip_index_format;
-  enum CanvasFrontFace front_face;
-  enum CanvasCullMode cull_mode;
-  bool unclipped_depth;
-} CanvasPrimitiveState;
+typedef struct CanvasTextureBindingLayout {
+  enum CanvasTextureSampleType sample_type;
+  enum CanvasTextureViewDimension view_dimension;
+  bool multisampled;
+} CanvasTextureBindingLayout;
 
 typedef enum CanvasGPUTextureFormat_Tag {
   /**
@@ -1237,6 +1354,151 @@ typedef struct CanvasGPUTextureFormat {
   };
 } CanvasGPUTextureFormat;
 
+typedef struct CanvasStorageTextureBindingLayout {
+  enum CanvasStorageTextureAccess access;
+  struct CanvasGPUTextureFormat format;
+  enum CanvasTextureViewDimension view_dimension;
+} CanvasStorageTextureBindingLayout;
+
+typedef enum CanvasBindingType_Tag {
+  CanvasBindingTypeBuffer,
+  CanvasBindingTypeSampler,
+  CanvasBindingTypeTexture,
+  CanvasBindingTypeStorageTexture,
+} CanvasBindingType_Tag;
+
+typedef struct CanvasBindingType {
+  CanvasBindingType_Tag tag;
+  union {
+    struct {
+      struct CanvasBufferBindingLayout buffer;
+    };
+    struct {
+      struct CanvasSamplerBindingLayout sampler;
+    };
+    struct {
+      struct CanvasTextureBindingLayout texture;
+    };
+    struct {
+      struct CanvasStorageTextureBindingLayout storage_texture;
+    };
+  };
+} CanvasBindingType;
+
+typedef struct CanvasBindGroupLayoutEntry {
+  uint32_t binding;
+  uint32_t visibility;
+  struct CanvasBindingType binding_type;
+} CanvasBindGroupLayoutEntry;
+
+typedef struct CanvasBufferBinding {
+  const struct CanvasGPUBuffer *buffer;
+  int64_t offset;
+  int64_t size;
+} CanvasBufferBinding;
+
+typedef enum CanvasBindGroupEntryResource_Tag {
+  CanvasBindGroupEntryResourceBuffer,
+  CanvasBindGroupEntryResourceSampler,
+  CanvasBindGroupEntryResourceTextureView,
+} CanvasBindGroupEntryResource_Tag;
+
+typedef struct CanvasBindGroupEntryResource {
+  CanvasBindGroupEntryResource_Tag tag;
+  union {
+    struct {
+      struct CanvasBufferBinding buffer;
+    };
+    struct {
+      const struct CanvasGPUSampler *sampler;
+    };
+    struct {
+      const struct CanvasGPUTextureView *texture_view;
+    };
+  };
+} CanvasBindGroupEntryResource;
+
+typedef struct CanvasBindGroupEntry {
+  uint32_t binding;
+  struct CanvasBindGroupEntryResource resource;
+} CanvasBindGroupEntry;
+
+typedef enum CanvasGPUPipelineLayoutOrGPUAutoLayoutMode_Tag {
+  CanvasGPUPipelineLayoutOrGPUAutoLayoutModeLayout,
+  CanvasGPUPipelineLayoutOrGPUAutoLayoutModeAuto,
+} CanvasGPUPipelineLayoutOrGPUAutoLayoutMode_Tag;
+
+typedef struct CanvasGPUPipelineLayoutOrGPUAutoLayoutMode {
+  CanvasGPUPipelineLayoutOrGPUAutoLayoutMode_Tag tag;
+  union {
+    struct {
+      const struct CanvasGPUPipelineLayout *layout;
+    };
+    struct {
+      enum CanvasGPUAutoLayoutMode auto_;
+    };
+  };
+} CanvasGPUPipelineLayoutOrGPUAutoLayoutMode;
+
+typedef struct CanvasProgrammableStage {
+  const struct CanvasGPUShaderModule *module;
+  const char *entry_point;
+  const struct CanvasConstants *constants;
+} CanvasProgrammableStage;
+
+typedef struct CanvasCreateRenderBundleEncoderDescriptor {
+  const char *label;
+  const struct CanvasGPUTextureFormat *color_formats;
+  uintptr_t color_formats_size;
+  const struct CanvasGPUTextureFormat *depth_stencil_format;
+  uint32_t sample_count;
+  bool depth_read_only;
+  bool stencil_read_only;
+} CanvasCreateRenderBundleEncoderDescriptor;
+
+typedef struct CanvasVertexAttribute {
+  enum CanvasVertexFormat format;
+  uint64_t offset;
+  uint32_t shader_location;
+} CanvasVertexAttribute;
+
+typedef struct CanvasVertexBufferLayout {
+  uint64_t array_stride;
+  enum CanvasVertexStepMode step_mode;
+  const struct CanvasVertexAttribute *attributes;
+  uintptr_t attributes_size;
+} CanvasVertexBufferLayout;
+
+typedef struct CanvasVertexState {
+  const struct CanvasGPUShaderModule *module;
+  const char *entry_point;
+  const struct CanvasConstants *constants;
+  const struct CanvasVertexBufferLayout *buffers;
+  uintptr_t buffers_size;
+} CanvasVertexState;
+
+typedef enum CanvasOptionalIndexFormat_Tag {
+  CanvasOptionalIndexFormatNone,
+  CanvasOptionalIndexFormatSome,
+} CanvasOptionalIndexFormat_Tag;
+
+typedef struct CanvasOptionalIndexFormat {
+  CanvasOptionalIndexFormat_Tag tag;
+  union {
+    struct {
+      enum CanvasIndexFormat some;
+    };
+  };
+} CanvasOptionalIndexFormat;
+
+typedef struct CanvasPrimitiveState {
+  enum CanvasPrimitiveTopology topology;
+  struct CanvasOptionalIndexFormat strip_index_format;
+  enum CanvasFrontFace front_face;
+  enum CanvasCullMode cull_mode;
+  bool unclipped_depth;
+} CanvasPrimitiveState;
+
 typedef struct CanvasStencilFaceState {
   enum CanvasCompareFunction compare;
   enum CanvasStencilOperation fail_op;
@@ -1356,6 +1618,34 @@ typedef struct CanvasCreateTextureDescriptor {
   uintptr_t view_formats_size;
 } CanvasCreateTextureDescriptor;
 
+typedef enum CanvasOptionalCompareFunction_Tag {
+  CanvasOptionalCompareFunctionNone,
+  CanvasOptionalCompareFunctionSome,
+} CanvasOptionalCompareFunction_Tag;
+
+typedef struct CanvasOptionalCompareFunction {
+  CanvasOptionalCompareFunction_Tag tag;
+  union {
+    struct {
+      enum CanvasCompareFunction some;
+    };
+  };
+} CanvasOptionalCompareFunction;
+
+typedef struct CanvasCreateSamplerDescriptor {
+  const char *label;
+  enum CanvasAddressMode address_mode_u;
+  enum CanvasAddressMode address_mode_v;
+  enum CanvasAddressMode address_mode_w;
+  enum CanvasFilterMode mag_filter;
+  enum CanvasFilterMode min_filter;
+  enum CanvasFilterMode mipmap_filter;
+  float lod_min_clamp;
+  float lod_max_clamp;
+  struct CanvasOptionalCompareFunction compare;
+  uint16_t max_anisotropy;
+} CanvasCreateSamplerDescriptor;
+
 typedef struct CanvasOrigin2d {
   /**
    *
@@ -4085,9 +4375,9 @@ void canvas_native_matrix_destroy(struct Matrix *value);
 
 void canvas_native_path_destroy(struct Path *value);
 
-struct CanvasWebGPUInstance *canvas_native_webgpu_instance_create(void);
+const struct CanvasWebGPUInstance *canvas_native_webgpu_instance_create(void);
 
-void canvas_native_webgpu_instance_destroy(struct CanvasWebGPUInstance *instance);
+void canvas_native_webgpu_instance_release(const struct CanvasWebGPUInstance *instance);
 
 void canvas_native_webgpu_request_adapter(const struct CanvasWebGPUInstance *instance,
                                           const struct CanvasGPURequestAdapterOptions *options,
@@ -4096,13 +4386,15 @@ void canvas_native_webgpu_request_adapter(const struct CanvasWebGPUInstance *ins
 
 char *canvas_native_webgpu_adapter_info_vendor(const struct CanvasGPUAdapterInfo *info);
 
-char *canvas_native_webgpu_adapter_info_architecture(const struct CanvasGPUAdapterInfo *info);
+char *canvas_native_webgpu_adapter_info_architecture(const struct CanvasGPUAdapterInfo *_info);
 
 char *canvas_native_webgpu_adapter_info_device(const struct CanvasGPUAdapterInfo *info);
 
 char *canvas_native_webgpu_adapter_info_description(const struct CanvasGPUAdapterInfo *info);
 
-void canvas_native_webgpu_adapter_info_destroy(struct CanvasGPUAdapterInfo *info);
+void canvas_native_webgpu_adapter_info_reference(const struct CanvasGPUAdapterInfo *info);
+
+void canvas_native_webgpu_adapter_info_release(const struct CanvasGPUAdapterInfo *info);
 
 struct StringBuffer *canvas_native_webgpu_adapter_get_features(const struct CanvasGPUAdapter *adapter);
 
@@ -4110,25 +4402,27 @@ bool canvas_native_webgpu_adapter_is_fallback_adapter(const struct CanvasGPUAdap
 
 struct CanvasGPUSupportedLimits *canvas_native_webgpu_adapter_get_limits(const struct CanvasGPUAdapter *adapter);
 
-struct CanvasGPUAdapterInfo *canvas_native_webgpu_request_adapter_info(struct CanvasGPUAdapter *adapter);
+const struct CanvasGPUAdapterInfo *canvas_native_webgpu_request_adapter_info(struct CanvasGPUAdapter *adapter);
 
-void canvas_native_webgpu_request_device(struct CanvasGPUAdapter *adapter,
+void canvas_native_webgpu_request_device(const struct CanvasGPUAdapter *adapter,
                                          const char *label,
                                          const char *const *required_features,
                                          uintptr_t required_features_length,
                                          const struct CanvasGPUSupportedLimits *required_limits,
-                                         void (*callback)(char*, struct CanvasGPUDevice*, void*),
+                                         void (*callback)(char*,
+                                                          const struct CanvasGPUDevice*,
+                                                          void*),
                                          void *callback_data);
 
 uint32_t canvas_native_webgpu_buffer_usage(const struct CanvasGPUBuffer *buffer);
 
 uint64_t canvas_native_webgpu_buffer_size(const struct CanvasGPUBuffer *buffer);
 
-char *canvas_native_webgpu_buffer_get_mapped_range(const struct CanvasGPUBuffer *buffer,
-                                                   int64_t offset,
-                                                   int64_t size,
-                                                   uint8_t *dst,
-                                                   uintptr_t dst_size);
+void canvas_native_webgpu_buffer_get_mapped_range(const struct CanvasGPUBuffer *buffer,
+                                                  int64_t offset,
+                                                  int64_t size,
+                                                  uint8_t *dst,
+                                                  uintptr_t dst_size);
 
 void canvas_native_webgpu_buffer_destroy(const struct CanvasGPUBuffer *buffer);
 
@@ -4141,95 +4435,173 @@ void canvas_native_webgpu_buffer_map_async(const struct CanvasGPUBuffer *buffer,
                                            void (*callback)(char*, void*),
                                            void *callback_data);
 
-struct CanvasGPUComputePass *canvas_native_webgpu_command_encoder_begin_compute_pass(struct CanvasGPUCommandEncoder *command_encoder,
-                                                                                     const struct CanvasGPUQuerySet *query_set,
-                                                                                     const char *label,
-                                                                                     int32_t beginning_of_pass_write_index,
-                                                                                     int32_t end_of_pass_write_index);
-
-struct CanvasGPURenderPass *canvas_native_webgpu_command_encoder_begin_render_pass(struct CanvasGPUCommandEncoder *command_encoder,
-                                                                                   const char *label,
-                                                                                   const struct CanvasRenderPassColorAttachment *color_attachments,
-                                                                                   uintptr_t color_attachments_size,
-                                                                                   const struct CanvasRenderPassDepthStencilAttachment *depth_stencil_attachment,
-                                                                                   const struct CanvasGPUQuerySet *occlusion_query_set,
-                                                                                   const struct CanvasGPUQuerySet *query_set,
-                                                                                   int32_t beginning_of_pass_write_index,
-                                                                                   int32_t end_of_pass_write_index);
-
-void canvas_native_webgpu_command_encoder_clear_buffer(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_reference(const struct CanvasGPUCommandEncoder *command_encoder);
+
+void canvas_native_webgpu_command_encoder_release(const struct CanvasGPUCommandEncoder *command_encoder);
+
+const struct CanvasGPUComputePassEncoder *canvas_native_webgpu_command_encoder_begin_compute_pass(const struct CanvasGPUCommandEncoder *command_encoder,
+                                                                                                  const struct CanvasGPUQuerySet *query_set,
+                                                                                                  const char *label,
+                                                                                                  int32_t beginning_of_pass_write_index,
+                                                                                                  int32_t end_of_pass_write_index);
+
+const struct CanvasGPURenderPassEncoder *canvas_native_webgpu_command_encoder_begin_render_pass(const struct CanvasGPUCommandEncoder *command_encoder,
+                                                                                                const char *label,
+                                                                                                const struct CanvasRenderPassColorAttachment *color_attachments,
+                                                                                                uintptr_t color_attachments_size,
+                                                                                                const struct CanvasRenderPassDepthStencilAttachment *depth_stencil_attachment,
+                                                                                                const struct CanvasGPUQuerySet *occlusion_query_set,
+                                                                                                const struct CanvasGPUQuerySet *query_set,
+                                                                                                int32_t beginning_of_pass_write_index,
+                                                                                                int32_t end_of_pass_write_index);
+
+void canvas_native_webgpu_command_encoder_clear_buffer(const struct CanvasGPUCommandEncoder *command_encoder,
                                                        const struct CanvasGPUBuffer *buffer,
                                                        int64_t offset,
                                                        int64_t size);
 
-void canvas_native_webgpu_command_encoder_copy_buffer_to_buffer(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_copy_buffer_to_buffer(const struct CanvasGPUCommandEncoder *command_encoder,
                                                                 const struct CanvasGPUBuffer *src,
                                                                 int64_t src_offset,
                                                                 const struct CanvasGPUBuffer *dst,
                                                                 int64_t dst_offset,
                                                                 uint64_t size);
 
-void canvas_native_webgpu_command_encoder_copy_buffer_to_texture(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_copy_buffer_to_texture(const struct CanvasGPUCommandEncoder *command_encoder,
                                                                  const struct CanvasImageCopyBuffer *src,
                                                                  const struct CanvasImageCopyTexture *dst,
                                                                  const struct CanvasExtent3d *copy_size);
 
-void canvas_native_webgpu_command_encoder_copy_texture_to_buffer(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_copy_texture_to_buffer(const struct CanvasGPUCommandEncoder *command_encoder,
                                                                  const struct CanvasImageCopyTexture *src,
                                                                  const struct CanvasImageCopyBuffer *dst,
                                                                  const struct CanvasExtent3d *copy_size);
 
-void canvas_native_webgpu_command_encoder_copy_texture_to_texture(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_copy_texture_to_texture(const struct CanvasGPUCommandEncoder *command_encoder,
                                                                   const struct CanvasImageCopyTexture *src,
                                                                   const struct CanvasImageCopyTexture *dst,
                                                                   const struct CanvasExtent3d *copy_size);
 
-struct CanvasGPUCommandBuffer *canvas_native_webgpu_command_encoder_finish(struct CanvasGPUCommandEncoder *command_encoder,
-                                                                           const char *label);
+const struct CanvasGPUCommandBuffer *canvas_native_webgpu_command_encoder_finish(const struct CanvasGPUCommandEncoder *command_encoder,
+                                                                                 const char *label);
 
-void canvas_native_webgpu_command_encoder_pop_debug_group(struct CanvasGPUCommandEncoder *command_encoder);
+void canvas_native_webgpu_command_encoder_pop_debug_group(const struct CanvasGPUCommandEncoder *command_encoder);
 
-void canvas_native_webgpu_command_encoder_push_debug_group(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_push_debug_group(const struct CanvasGPUCommandEncoder *command_encoder,
                                                            const char *label);
 
-void canvas_native_webgpu_command_encoder_resolve_query_set(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_resolve_query_set(const struct CanvasGPUCommandEncoder *command_encoder,
                                                             const struct CanvasGPUQuerySet *query_set,
                                                             uint32_t first_query,
                                                             uint32_t query_count,
                                                             struct CanvasGPUBuffer *dst,
                                                             uint64_t dst_offset);
 
-void canvas_native_webgpu_command_encoder_write_timestamp(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_write_timestamp(const struct CanvasGPUCommandEncoder *command_encoder,
                                                           const struct CanvasGPUQuerySet *query_set,
                                                           uint32_t query_index);
 
+void canvas_native_webgpu_compute_pass_reference(const struct CanvasGPUComputePassEncoder *compute_pass);
+
+void canvas_native_webgpu_compute_pass_release(const struct CanvasGPUComputePassEncoder *compute_pass);
+
+void canvas_native_webgpu_compute_pass_dispatch_workgroups(const struct CanvasGPUComputePassEncoder *compute_pass,
+                                                           uint32_t workgroup_count_x,
+                                                           uint32_t workgroup_count_y,
+                                                           uint32_t workgroup_count_z);
+
+void canvas_native_webgpu_compute_pass_dispatch_workgroups_indirect(const struct CanvasGPUComputePassEncoder *compute_pass,
+                                                                    const struct CanvasGPUBuffer *indirect_buffer,
+                                                                    uintptr_t indirect_offset);
+
+void canvas_native_webgpu_compute_pass_end(const struct CanvasGPUComputePassEncoder *compute_pass);
+
+void canvas_native_webgpu_compute_pass_insert_debug_marker(const struct CanvasGPUComputePassEncoder *compute_pass,
+                                                           const char *label);
+
+void canvas_native_webgpu_compute_pass_pop_debug_group(const struct CanvasGPUComputePassEncoder *compute_pass);
+
+void canvas_native_webgpu_compute_pass_push_debug_group(const struct CanvasGPUComputePassEncoder *compute_pass,
+                                                        const char *label);
+
+void canvas_native_webgpu_compute_pass_set_bind_group(const struct CanvasGPUComputePassEncoder *compute_pass,
+                                                      uint32_t index,
+                                                      const struct CanvasGPUBindGroup *bind_group,
+                                                      const uint32_t *dynamic_offsets,
+                                                      uintptr_t dynamic_offsets_size,
+                                                      uintptr_t dynamic_offsets_start,
+                                                      uintptr_t dynamic_offsets_length);
+
+void canvas_native_webgpu_compute_pass_set_pipeline(struct CanvasGPUComputePassEncoder *compute_pass,
+                                                    const struct CanvasGPUComputePipeline *pipeline);
+
 struct StringBuffer *canvas_native_webgpu_device_get_features(const struct CanvasGPUDevice *device);
 
 struct CanvasGPUSupportedLimits *canvas_native_webgpu_device_get_limits(const struct CanvasGPUDevice *device);
 
-struct CanvasGPUQueue *canvas_native_webgpu_device_get_queue(const struct CanvasGPUDevice *device);
+const struct CanvasGPUQueue *canvas_native_webgpu_device_get_queue(const struct CanvasGPUDevice *device);
 
 void canvas_native_webgpu_device_set_lost_callback(const struct CanvasGPUDevice *device,
                                                    void (*callback)(int32_t, char*, void*),
-                                                   void *callback_data);
+                                                   void *userdata);
 
 void canvas_native_webgpu_device_destroy(const struct CanvasGPUDevice *device);
 
-void canvas_native_webgpu_device_destroy_destory(struct CanvasGPUDevice *device);
+void canvas_native_webgpu_device_reference(const struct CanvasGPUDevice *device);
 
-struct CanvasGPUCommandEncoder *canvas_native_webgpu_device_create_command_encoder(const struct CanvasGPUDevice *device,
-                                                                                   const char *label);
+void canvas_native_webgpu_device_release(const struct CanvasGPUDevice *device);
 
-struct CanvasGPUShaderModule *canvas_native_webgpu_device_create_shader_module(const struct CanvasGPUDevice *device,
+const struct CanvasGPUBindGroupLayout *canvas_native_webgpu_device_create_bind_group_layout(const struct CanvasGPUDevice *device,
+                                                                                            const char *label,
+                                                                                            const struct CanvasBindGroupLayoutEntry *entries,
+                                                                                            uintptr_t size);
+
+const struct CanvasGPUBindGroup *canvas_native_webgpu_device_create_bind_group(const struct CanvasGPUDevice *device,
                                                                                const char *label,
-                                                                               const char *source);
+                                                                               const struct CanvasGPUBindGroupLayout *layout,
+                                                                               const struct CanvasBindGroupEntry *entries,
+                                                                               uintptr_t size);
+
+const struct CanvasGPUCommandEncoder *canvas_native_webgpu_device_create_command_encoder(const struct CanvasGPUDevice *device,
+                                                                                         const char *label);
+
+const struct CanvasGPUComputePipeline *canvas_native_webgpu_device_create_compute_pipeline(const struct CanvasGPUDevice *device,
+                                                                                           const char *label,
+                                                                                           struct CanvasGPUPipelineLayoutOrGPUAutoLayoutMode layout,
+                                                                                           const struct CanvasProgrammableStage *compute);
+
+void canvas_native_webgpu_device_create_compute_pipeline_async(const struct CanvasGPUDevice *device,
+                                                               const char *label,
+                                                               struct CanvasGPUPipelineLayoutOrGPUAutoLayoutMode layout,
+                                                               const struct CanvasProgrammableStage *compute,
+                                                               void (*callback)(const struct CanvasGPUComputePipeline*,
+                                                                                enum CanvasGPUErrorType,
+                                                                                char*,
+                                                                                void*),
+                                                               void *callback_data);
+
+const struct CanvasGPUPipelineLayout *canvas_native_webgpu_device_create_pipeline_layout(const struct CanvasGPUDevice *device,
+                                                                                         const char *label,
+                                                                                         const struct CanvasGPUBindGroupLayout *group_layouts,
+                                                                                         uintptr_t size);
+
+const struct CanvasGPUQuerySet *canvas_native_webgpu_device_create_query_set(const struct CanvasGPUDevice *device,
+                                                                             const char *label,
+                                                                             enum CanvasQueryType type_,
+                                                                             uint32_t count);
+
+const struct CanvasGPURenderBundleEncoder *canvas_native_webgpu_device_create_render_bundle_encoder(const struct CanvasGPUDevice *device,
+                                                                                                    const struct CanvasCreateRenderBundleEncoderDescriptor *descriptor);
+
+const struct CanvasGPUShaderModule *canvas_native_webgpu_device_create_shader_module(const struct CanvasGPUDevice *device,
+                                                                                     const char *label,
+                                                                                     const char *source);
 
-struct CanvasGPUBuffer *canvas_native_webgpu_device_create_buffer(const struct CanvasGPUDevice *device,
-                                                                  const char *label,
-                                                                  uint64_t size,
-                                                                  uint32_t usage,
-                                                                  bool mapped_at_creation,
-                                                                  char *error);
+const struct CanvasGPUBuffer *canvas_native_webgpu_device_create_buffer(const struct CanvasGPUDevice *device,
+                                                                        const char *label,
+                                                                        uint64_t size,
+                                                                        uint32_t usage,
+                                                                        bool mapped_at_creation);
 
 struct CanvasConstants *canvas_native_webgpu_constants_create(void);
 
@@ -4239,35 +4611,45 @@ void canvas_native_webgpu_constants_insert(struct CanvasConstants *constants,
 
 void canvas_native_webgpu_constants_destroy(struct CanvasConstants *constants);
 
-struct CanvasGPURenderPipeline *canvas_native_webgpu_device_create_render_pipeline(const struct CanvasGPUDevice *device,
-                                                                                   const struct CanvasCreateRenderPipelineDescriptor *descriptor);
+const struct CanvasGPURenderPipeline *canvas_native_webgpu_device_create_render_pipeline(const struct CanvasGPUDevice *device,
+                                                                                         const struct CanvasCreateRenderPipelineDescriptor *descriptor);
 
-struct CanvasGPUTexture *canvas_native_webgpu_device_create_texture(const struct CanvasGPUDevice *device,
-                                                                    const struct CanvasCreateTextureDescriptor *descriptor,
-                                                                    char *error);
+void canvas_native_webgpu_device_create_render_pipeline_async(const struct CanvasGPUDevice *device,
+                                                              const struct CanvasCreateRenderPipelineDescriptor *descriptor,
+                                                              void (*callback)(const struct CanvasGPURenderPipeline*,
+                                                                               enum CanvasGPUErrorType,
+                                                                               char*,
+                                                                               void*),
+                                                              void *callback_data);
 
-void canvas_native_webgpu_queue_copy_external_image_to_texture(struct CanvasGPUQueue *queue,
+const struct CanvasGPUTexture *canvas_native_webgpu_device_create_texture(const struct CanvasGPUDevice *device,
+                                                                          const struct CanvasCreateTextureDescriptor *descriptor);
+
+const struct CanvasGPUSampler *canvas_native_webgpu_device_create_sampler(const struct CanvasGPUDevice *device,
+                                                                          const struct CanvasCreateSamplerDescriptor *descriptor);
+
+void canvas_native_webgpu_queue_copy_external_image_to_texture(const struct CanvasGPUQueue *queue,
                                                                const struct CanvasImageCopyExternalImage *source,
                                                                const struct CanvasImageCopyTexture *destination,
                                                                const struct CanvasExtent3d *size);
 
-void canvas_native_webgpu_queue_on_submitted_work_done(struct CanvasGPUQueue *queue,
+void canvas_native_webgpu_queue_on_submitted_work_done(const struct CanvasGPUQueue *queue,
                                                        void (*callback)(char*, void*),
                                                        void *callback_data);
 
-void canvas_native_webgpu_queue_submit(struct CanvasGPUQueue *queue,
+void canvas_native_webgpu_queue_submit(const struct CanvasGPUQueue *queue,
                                        const struct CanvasGPUCommandBuffer *const *command_buffers,
                                        uintptr_t command_buffers_size);
 
-void canvas_native_webgpu_queue_write_buffer(struct CanvasGPUQueue *queue,
-                                             struct CanvasGPUBuffer *buffer,
+void canvas_native_webgpu_queue_write_buffer(const struct CanvasGPUQueue *queue,
+                                             const struct CanvasGPUBuffer *buffer,
                                              uint64_t buffer_offset,
                                              const uint8_t *data,
                                              uintptr_t data_size,
                                              uintptr_t data_offset,
                                              intptr_t size);
 
-void canvas_native_webgpu_queue_write_texture(struct CanvasGPUQueue *queue,
+void canvas_native_webgpu_queue_write_texture(const struct CanvasGPUQueue *queue,
                                               const struct CanvasImageCopyTexture *destination,
                                               const struct CanvasImageDataLayout *data_layout,
                                               const struct CanvasExtent3d *size,
@@ -4276,49 +4658,49 @@ void canvas_native_webgpu_queue_write_texture(struct CanvasGPUQueue *queue,
 
 struct CanvasGPUSupportedLimits *canvas_native_webgpu_create_limits(void);
 
-void canvas_native_webgpu_limits_destroy(struct CanvasGPUSupportedLimits *limits);
+void canvas_native_webgpu_limits_release(struct CanvasGPUSupportedLimits *limits);
 
-void canvas_native_webgpu_render_pass_begin_occlusion_query(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_begin_occlusion_query(const struct CanvasGPURenderPassEncoder *render_pass,
                                                             uint32_t query_index);
 
-void canvas_native_webgpu_render_pass_encoder_draw(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_encoder_draw(const struct CanvasGPURenderPassEncoder *render_pass,
                                                    uint32_t vertex_count,
                                                    uint32_t instance_count,
                                                    uint32_t first_vertex,
                                                    uint32_t first_instance);
 
-void canvas_native_webgpu_render_pass_draw_indexed(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_draw_indexed(const struct CanvasGPURenderPassEncoder *render_pass,
                                                    uint32_t index_count,
                                                    uint32_t instance_count,
                                                    uint32_t first_index,
                                                    int32_t base_vertex,
                                                    uint32_t first_instance);
 
-void canvas_native_webgpu_render_pass_draw_indexed_indirect(struct CanvasGPURenderPass *render_pass,
-                                                            struct CanvasGPUBuffer *indirect_buffer,
+void canvas_native_webgpu_render_pass_draw_indexed_indirect(const struct CanvasGPURenderPassEncoder *render_pass,
+                                                            const struct CanvasGPUBuffer *indirect_buffer,
                                                             uint64_t indirect_offset);
 
-void canvas_native_webgpu_render_pass_draw_indirect(struct CanvasGPURenderPass *render_pass,
-                                                    struct CanvasGPUBuffer *indirect_buffer,
+void canvas_native_webgpu_render_pass_draw_indirect(const struct CanvasGPURenderPassEncoder *render_pass,
+                                                    const struct CanvasGPUBuffer *indirect_buffer,
                                                     uint64_t indirect_offset);
 
-void canvas_native_webgpu_render_pass_end(struct CanvasGPURenderPass *render_pass);
+void canvas_native_webgpu_render_pass_end(const struct CanvasGPURenderPassEncoder *render_pass);
 
-void canvas_native_webgpu_render_pass_end_occlusion_query(struct CanvasGPURenderPass *render_pass);
+void canvas_native_webgpu_render_pass_end_occlusion_query(const struct CanvasGPURenderPassEncoder *render_pass);
 
-void canvas_native_webgpu_render_pass_execute_bundles(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_execute_bundles(const struct CanvasGPURenderPassEncoder *render_pass,
                                                       const struct CanvasGPURenderBundle *bundles,
                                                       uintptr_t bundles_size);
 
-void canvas_native_webgpu_render_pass_insert_debug_marker(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_insert_debug_marker(const struct CanvasGPURenderPassEncoder *render_pass,
                                                           const char *label);
 
-void canvas_native_webgpu_render_pass_pop_debug_group(struct CanvasGPURenderPass *render_pass);
+void canvas_native_webgpu_render_pass_pop_debug_group(const struct CanvasGPURenderPassEncoder *render_pass);
 
-void canvas_native_webgpu_render_pass_push_debug_group(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_push_debug_group(const struct CanvasGPURenderPassEncoder *render_pass,
                                                        const char *label);
 
-void canvas_native_webgpu_render_pass_set_bind_group(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_bind_group(const struct CanvasGPURenderPassEncoder *render_pass,
                                                      uint32_t index,
                                                      const struct CanvasGPUBindGroup *bind_group,
                                                      const uint32_t *dynamic_offsets,
@@ -4326,34 +4708,34 @@ void canvas_native_webgpu_render_pass_set_bind_group(struct CanvasGPURenderPass
                                                      uintptr_t dynamic_offsets_start,
                                                      uintptr_t dynamic_offsets_length);
 
-void canvas_native_webgpu_render_pass_set_blend_constant(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_blend_constant(const struct CanvasGPURenderPassEncoder *render_pass,
                                                          const struct CanvasColor *color);
 
-void canvas_native_webgpu_render_pass_set_index_buffer(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_index_buffer(const struct CanvasGPURenderPassEncoder *render_pass,
                                                        const struct CanvasGPUBuffer *buffer,
                                                        enum CanvasIndexFormat index_format,
                                                        int64_t offset,
                                                        int64_t size);
 
-void canvas_native_webgpu_render_pass_set_pipeline(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_pipeline(const struct CanvasGPURenderPassEncoder *render_pass,
                                                    const struct CanvasGPURenderPipeline *pipeline);
 
-void canvas_native_webgpu_render_pass_set_scissor_rect(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_scissor_rect(const struct CanvasGPURenderPassEncoder *render_pass,
                                                        uint32_t x,
                                                        uint32_t y,
                                                        uint32_t width,
                                                        uint32_t height);
 
-void canvas_native_webgpu_render_pass_set_stencil_reference(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_stencil_reference(const struct CanvasGPURenderPassEncoder *render_pass,
                                                             uint32_t reference);
 
-void canvas_native_webgpu_render_pass_set_vertex_buffer(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_vertex_buffer(const struct CanvasGPURenderPassEncoder *render_pass,
                                                         uint32_t slot,
-                                                        struct CanvasGPUBuffer *buffer,
+                                                        const struct CanvasGPUBuffer *buffer,
                                                         int64_t offset,
                                                         int64_t size);
 
-void canvas_native_webgpu_render_pass_set_viewport(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_viewport(const struct CanvasGPURenderPassEncoder *render_pass,
                                                    float x,
                                                    float y,
                                                    float width,
@@ -4361,73 +4743,105 @@ void canvas_native_webgpu_render_pass_set_viewport(struct CanvasGPURenderPass *r
                                                    float depth_min,
                                                    float depth_max);
 
+void canvas_native_webgpu_render_pass_reference(const struct CanvasGPURenderPassEncoder *render_pass);
+
+void canvas_native_webgpu_render_pass_release(const struct CanvasGPURenderPassEncoder *render_pass);
+
 #if defined(TARGET_OS_ANDROID)
-struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create(struct CanvasWebGPUInstance *instance,
-                                                                   void *window,
-                                                                   uint32_t width,
-                                                                   uint32_t height);
+const struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create(struct CanvasWebGPUInstance *instance,
+                                                                         void *window,
+                                                                         uint32_t width,
+                                                                         uint32_t height);
 #endif
 
 #if (defined(TARGET_OS_IOS) || defined(TARGET_OS_MACOS))
-struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create(struct CanvasWebGPUInstance *instance,
-                                                                   void *view,
-                                                                   uint32_t width,
-                                                                   uint32_t height);
+const struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create(const struct CanvasWebGPUInstance *instance,
+                                                                         void *view,
+                                                                         uint32_t width,
+                                                                         uint32_t height);
 #endif
 
 #if defined(TARGET_OS_IOS)
-struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create_uiview(struct CanvasWebGPUInstance *instance,
-                                                                          void *view,
-                                                                          uint32_t width,
-                                                                          uint32_t height);
+const struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create_uiview(const struct CanvasWebGPUInstance *instance,
+                                                                                void *view,
+                                                                                uint32_t width,
+                                                                                uint32_t height);
 #endif
 
 #if defined(TARGET_OS_MACOS)
-struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create_nsview(struct CanvasWebGPUInstance *instance,
-                                                                          void *view,
-                                                                          uint32_t width,
-                                                                          uint32_t height);
+const struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create_nsview(const struct CanvasWebGPUInstance *instance,
+                                                                                void *view,
+                                                                                uint32_t width,
+                                                                                uint32_t height);
 #endif
 
-void canvas_native_webgpu_context_configure(struct CanvasGPUCanvasContext *context,
-                                            struct CanvasGPUDevice *device,
+void canvas_native_webgpu_context_configure(const struct CanvasGPUCanvasContext *context,
+                                            const struct CanvasGPUDevice *device,
                                             const struct CanvasGPUSurfaceConfiguration *config);
 
-void canvas_native_webgpu_context_unconfigure(struct CanvasGPUCanvasContext *context,
+void canvas_native_webgpu_context_unconfigure(const struct CanvasGPUCanvasContext *context,
                                               struct CanvasGPUDevice *device,
                                               const struct CanvasGPUSurfaceConfiguration *config);
 
-struct CanvasGPUTexture *canvas_native_webgpu_context_get_current_texture(struct CanvasGPUCanvasContext *context);
+const struct CanvasGPUTexture *canvas_native_webgpu_context_get_current_texture(const struct CanvasGPUCanvasContext *context);
+
+void canvas_native_webgpu_context_present_surface(const struct CanvasGPUCanvasContext *context);
+
+void canvas_native_webgpu_context_get_capabilities(const struct CanvasGPUCanvasContext *context,
+                                                   const struct CanvasGPUAdapter *adapter);
 
 char *canvas_native_webgpu_enum_gpu_texture_to_string(struct CanvasGPUTextureFormat value);
 
 struct CanvasOptionalGPUTextureFormat canvas_native_webgpu_string_to_gpu_texture_enum(const char *format);
 
-struct CanvasGPUTextureView *canvas_native_webgpu_texture_create_texture_view(struct CanvasGPUTexture *texture,
-                                                                              const struct CanvasCreateTextureViewDescriptor *descriptor);
+void canvas_native_webgpu_texture_reference(const struct CanvasGPUTexture *texture);
+
+void canvas_native_webgpu_texture_release(const struct CanvasGPUTexture *texture);
+
+const struct CanvasGPUTextureView *canvas_native_webgpu_texture_create_texture_view(const struct CanvasGPUTexture *texture,
+                                                                                    const struct CanvasCreateTextureViewDescriptor *descriptor);
+
+uint32_t canvas_native_webgpu_texture_get_depth_or_array_layers(const struct CanvasGPUTexture *texture);
+
+uint32_t canvas_native_webgpu_texture_get_width(const struct CanvasGPUTexture *texture);
+
+uint32_t canvas_native_webgpu_texture_get_height(const struct CanvasGPUTexture *texture);
+
+enum CanvasTextureDimension canvas_native_webgpu_texture_get_dimension(const struct CanvasGPUTexture *texture);
+
+struct CanvasGPUTextureFormat canvas_native_webgpu_texture_get_format(const struct CanvasGPUTexture *texture);
+
+uint32_t canvas_native_webgpu_texture_get_usage(const struct CanvasGPUTexture *texture);
+
+char *canvas_native_webgpu_texture_get_label(const struct CanvasGPUTexture *_texture);
+
+uint32_t canvas_native_webgpu_texture_get_mip_level_count(const struct CanvasGPUTexture *texture);
+
+uint32_t canvas_native_webgpu_texture_get_sample_count(const struct CanvasGPUTexture *texture);
 
-uint32_t canvas_native_webgpu_texture_get_depth_or_array_layers(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_texture_destroy(const struct CanvasGPUTexture *texture);
 
-uint32_t canvas_native_webgpu_texture_get_width(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_texture_view_reference(const struct CanvasGPUTextureView *texture_view);
 
-uint32_t canvas_native_webgpu_texture_get_height(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_texture_view_release(const struct CanvasGPUTextureView *texture_view);
 
-enum CanvasTextureDimension canvas_native_webgpu_texture_get_dimension(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_bind_group_reference(const struct CanvasGPUBindGroup *bind_group);
 
-struct CanvasGPUTextureFormat canvas_native_webgpu_texture_get_format(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_bind_group_release(const struct CanvasGPUBindGroup *bind_group);
 
-uint32_t canvas_native_webgpu_texture_get_usage(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_bind_group_layout_reference(const struct CanvasGPUBindGroupLayout *bind_group_layout);
 
-char *canvas_native_webgpu_texture_get_label(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_bind_group_layout_release(const struct CanvasGPUBindGroupLayout *bind_group_layout);
 
-uint32_t canvas_native_webgpu_texture_get_mip_level_count(struct CanvasGPUTexture *texture);
+const struct CanvasGPUBindGroupLayout *canvas_native_webgpu_render_pipeline_get_bind_group_layout(const struct CanvasGPURenderPipeline *pipeline,
+                                                                                                  uint32_t index);
 
-uint32_t canvas_native_webgpu_texture_get_sample_count(struct CanvasGPUTexture *texture);
+enum CanvasGPUErrorType canvas_native_webgpu_error_get_type(const struct CanvasGPUError *error);
 
-char *canvas_native_webgpu_texture_destroy(struct CanvasGPUTexture *texture);
+char *canvas_native_webgpu_error_get_message(const struct CanvasGPUError *error);
 
-struct CanvasGPUBindGroupLayout *canvas_native_webgpu_render_pipeline_get_bind_group_layout(const struct CanvasGPURenderPipeline *pipeline,
-                                                                                            uint32_t index);
+const struct CanvasGPUBindGroupLayout *canvas_native_webgpu_compute_pipeline_get_bind_group_layout(const struct CanvasGPUComputePipeline *pipeline,
+                                                                                                   uint32_t index);
 
 const uint8_t *canvas_native_u8_buffer_get_bytes(const struct U8Buffer *buffer);
 
diff --git a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative
index 97a24028f..ec119f46d 100644
Binary files a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative and b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative differ
diff --git a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/Relocations/aarch64/CanvasNative.yml b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/Relocations/aarch64/CanvasNative.yml
index 04564eeaf..43812958c 100644
--- a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/Relocations/aarch64/CanvasNative.yml
+++ b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/Relocations/aarch64/CanvasNative.yml
@@ -2,606 +2,606 @@
 triple:          'arm64-apple-darwin'
 binary-path:     '/Users/triniwiz/Documents/GitHub/canvas/packages/canvas/src-native/canvas-ios/dist/Release-iphoneos/CanvasNative.framework/CanvasNative'
 relocations:
-  - { offsetInCU: 0x34, offset: 0x7718F, size: 0x8, addend: 0x0, symName: _CanvasNativeVersionString, symObjAddr: 0x0, symBinAddr: 0x8EC000, symSize: 0x0 }
-  - { offsetInCU: 0x69, offset: 0x771C4, size: 0x8, addend: 0x0, symName: _CanvasNativeVersionNumber, symObjAddr: 0x38, symBinAddr: 0x8EC038, symSize: 0x0 }
-  - { offsetInCU: 0x3F, offset: 0x77219, size: 0x8, addend: 0x0, symName: ___swift_memcpy16_8, symObjAddr: 0x28, symBinAddr: 0x8028, symSize: 0xC }
-  - { offsetInCU: 0x53, offset: 0x7722D, size: 0x8, addend: 0x0, symName: ___swift_noop_void_return, symObjAddr: 0x34, symBinAddr: 0x8034, symSize: 0x4 }
-  - { offsetInCU: 0x67, offset: 0x77241, size: 0x8, addend: 0x0, symName: '_$sSo6CGSizeVwet', symObjAddr: 0x38, symBinAddr: 0x8038, symSize: 0x20 }
-  - { offsetInCU: 0x7B, offset: 0x77255, size: 0x8, addend: 0x0, symName: '_$sSo6CGSizeVwst', symObjAddr: 0x58, symBinAddr: 0x8058, symSize: 0x28 }
-  - { offsetInCU: 0x8F, offset: 0x77269, size: 0x8, addend: 0x0, symName: '_$sSo6CGRectVwCP', symObjAddr: 0x94, symBinAddr: 0x8094, symSize: 0x30 }
-  - { offsetInCU: 0xA3, offset: 0x7727D, size: 0x8, addend: 0x0, symName: ___swift_memcpy32_8, symObjAddr: 0xC4, symBinAddr: 0x80C4, symSize: 0xC }
-  - { offsetInCU: 0xB7, offset: 0x77291, size: 0x8, addend: 0x0, symName: '_$sSo6CGRectVwet', symObjAddr: 0xD0, symBinAddr: 0x80D0, symSize: 0x20 }
-  - { offsetInCU: 0xCB, offset: 0x772A5, size: 0x8, addend: 0x0, symName: '_$sSo6CGRectVwst', symObjAddr: 0xF0, symBinAddr: 0x80F0, symSize: 0x2C }
-  - { offsetInCU: 0x4F, offset: 0x7748E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC11_WriteQueue33_05178D28796EA758448493B56DC45144LLSo011NSOperationE0CSgvpZ', symObjAddr: 0x2AE8, symBinAddr: 0x10D39A0, symSize: 0x0 }
-  - { offsetInCU: 0x69, offset: 0x774A8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10_ReadQueue33_05178D28796EA758448493B56DC45144LLSo011NSOperationE0CSgvpZ', symObjAddr: 0x2AF0, symBinAddr: 0x10D39A8, symSize: 0x0 }
-  - { offsetInCU: 0x9D, offset: 0x774DC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC19getBytesFromUIImageySo13NSMutableDataCSo0G0CFZTo', symObjAddr: 0x4, symBinAddr: 0x8194, symSize: 0x38 }
-  - { offsetInCU: 0xF3, offset: 0x77532, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13createPatternys5Int64VAF_So7UIImageCSStFZTo', symObjAddr: 0x40, symBinAddr: 0x81D0, symSize: 0x70 }
-  - { offsetInCU: 0x144, offset: 0x77583, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC25loadImageAssetWithContextySbs5Int64V_So7UIImageCtFZTo', symObjAddr: 0xB4, symBinAddr: 0x8244, symSize: 0x44 }
-  - { offsetInCU: 0x19F, offset: 0x775DE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dyys5Int64V_So7UIImageCS2ftFZTo', symObjAddr: 0xFC, symBinAddr: 0x828C, symSize: 0x50 }
-  - { offsetInCU: 0x204, offset: 0x77643, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dy2dw2dhys5Int64V_So7UIImageCS4ftFZTo', symObjAddr: 0x150, symBinAddr: 0x82E0, symSize: 0x68 }
-  - { offsetInCU: 0x27D, offset: 0x776BC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2sx2sy2sw2sh2dx2dy2dw2dhys5Int64V_So7UIImageCS8ftFZTo', symObjAddr: 0x1BC, symBinAddr: 0x834C, symSize: 0x98 }
-  - { offsetInCU: 0x2DA, offset: 0x77719, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23initWebGPUWithViewLayerys5Int64VAF_AFs6UInt32VAHtFZTo', symObjAddr: 0x258, symBinAddr: 0x83E8, symSize: 0x14 }
-  - { offsetInCU: 0x35C, offset: 0x7779B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC18initWebGPUWithViewys5Int64VAF_AFs6UInt32VAHtFZTo', symObjAddr: 0x270, symBinAddr: 0x8400, symSize: 0x14 }
-  - { offsetInCU: 0x40B, offset: 0x7784A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14initGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbtFZTo', symObjAddr: 0x2C8, symBinAddr: 0x8458, symSize: 0x50 }
-  - { offsetInCU: 0x4DC, offset: 0x7791B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC20initSharedGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbAFtFZTo', symObjAddr: 0x364, symBinAddr: 0x84F4, symSize: 0x58 }
-  - { offsetInCU: 0x5B6, offset: 0x779F5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC24initGLWithWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbtFZTo', symObjAddr: 0x404, symBinAddr: 0x8594, symSize: 0x58 }
-  - { offsetInCU: 0x695, offset: 0x77AD4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC26initSharedGLWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbAFtFZTo', symObjAddr: 0x4AC, symBinAddr: 0x863C, symSize: 0x60 }
-  - { offsetInCU: 0x741, offset: 0x77B80, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15resize2DContextyys5Int64V_S2ftFZTo', symObjAddr: 0x510, symBinAddr: 0x86A0, symSize: 0x8 }
-  - { offsetInCU: 0x7AA, offset: 0x77BE9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14flush2DContextyys5Int64VFZTo', symObjAddr: 0x51C, symBinAddr: 0x86AC, symSize: 0x8 }
-  - { offsetInCU: 0x801, offset: 0x77C40, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC7flushGLySbs5Int64VFZTo', symObjAddr: 0x538, symBinAddr: 0x86C8, symSize: 0x8 }
-  - { offsetInCU: 0x858, offset: 0x77C97, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9releaseGLyys5Int64VFZTo', symObjAddr: 0x544, symBinAddr: 0x86D4, symSize: 0x8 }
-  - { offsetInCU: 0x8AF, offset: 0x77CEE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC12getGLPointerys5Int64VAFFZTo', symObjAddr: 0x550, symBinAddr: 0x86E0, symSize: 0x8 }
-  - { offsetInCU: 0x906, offset: 0x77D45, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC16releaseGLPointeryys5Int64VFZTo', symObjAddr: 0x55C, symBinAddr: 0x86EC, symSize: 0x8 }
-  - { offsetInCU: 0x985, offset: 0x77DC4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15create2DContextys5Int64VAF_s5Int32VAHSbSfA2HSfAHtFZTo', symObjAddr: 0x56C, symBinAddr: 0x86FC, symSize: 0x24 }
-  - { offsetInCU: 0xA36, offset: 0x77E75, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23updateGLSurfaceWithViewyys5Int64V_s5Int32VAhFtFZTo', symObjAddr: 0x594, symBinAddr: 0x8724, symSize: 0x14 }
-  - { offsetInCU: 0xAA9, offset: 0x77EE8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC6test2Dyys5Int64VFZTo', symObjAddr: 0x5AC, symBinAddr: 0x873C, symSize: 0x8 }
-  - { offsetInCU: 0xB00, offset: 0x77F3F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13testToDataURLySSs5Int64VFZTo', symObjAddr: 0x60C, symBinAddr: 0x879C, symSize: 0x74 }
-  - { offsetInCU: 0xB8B, offset: 0x77FCA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZTo', symObjAddr: 0x814, symBinAddr: 0x89A4, symSize: 0xA0 }
-  - { offsetInCU: 0xBDC, offset: 0x7801B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZTo', symObjAddr: 0xB1C, symBinAddr: 0x8CAC, symSize: 0x98 }
-  - { offsetInCU: 0xC2D, offset: 0x7806C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZTo', symObjAddr: 0xE70, symBinAddr: 0x9000, symSize: 0x98 }
-  - { offsetInCU: 0xC89, offset: 0x780C8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZTo', symObjAddr: 0x1298, symBinAddr: 0x9428, symSize: 0xD8 }
-  - { offsetInCU: 0xCD1, offset: 0x78110, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC32getPixelsPerInchForCurrentDeviceSSyFZTo', symObjAddr: 0x1374, symBinAddr: 0x9504, symSize: 0x34 }
-  - { offsetInCU: 0xD31, offset: 0x78170, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCACycfcTo', symObjAddr: 0x13F8, symBinAddr: 0x9588, symSize: 0x3C }
-  - { offsetInCU: 0xD82, offset: 0x781C1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC19getBytesFromUIImageySo13NSMutableDataCSo0G0CFZTf4nd_n', symObjAddr: 0x1468, symBinAddr: 0x95F8, symSize: 0x2AC }
-  - { offsetInCU: 0xFB6, offset: 0x783F5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13createPatternys5Int64VAF_So7UIImageCSStFZTf4nnnd_n', symObjAddr: 0x1714, symBinAddr: 0x98A4, symSize: 0x264 }
-  - { offsetInCU: 0x11B0, offset: 0x785EF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC25loadImageAssetWithContextySbs5Int64V_So7UIImageCtFZTf4nnd_n', symObjAddr: 0x1978, symBinAddr: 0x9B08, symSize: 0xEC }
-  - { offsetInCU: 0x12AD, offset: 0x786EC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dyys5Int64V_So7UIImageCS2ftFZTf4nnnnd_n', symObjAddr: 0x1A64, symBinAddr: 0x9BF4, symSize: 0x1B4 }
-  - { offsetInCU: 0x1422, offset: 0x78861, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dy2dw2dhys5Int64V_So7UIImageCS4ftFZTf4nnnnnnd_n', symObjAddr: 0x1C18, symBinAddr: 0x9DA8, symSize: 0x1CC }
-  - { offsetInCU: 0x15B7, offset: 0x789F6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2sx2sy2sw2sh2dx2dy2dw2dhys5Int64V_So7UIImageCS8ftFZTf4nnnnnnnnnnd_n', symObjAddr: 0x1DE4, symBinAddr: 0x9F74, symSize: 0x1E0 }
-  - { offsetInCU: 0x17A3, offset: 0x78BE2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZTf4nnnd_n', symObjAddr: 0x1FC4, symBinAddr: 0xA154, symSize: 0x1B4 }
-  - { offsetInCU: 0x186D, offset: 0x78CAC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZTf4nnnnd_n', symObjAddr: 0x231C, symBinAddr: 0xA4AC, symSize: 0x1D4 }
-  - { offsetInCU: 0x194E, offset: 0x78D8D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC32getPixelsPerInchForCurrentDeviceSSyFZTf4d_n', symObjAddr: 0x24F0, symBinAddr: 0xA680, symSize: 0x114 }
-  - { offsetInCU: 0x19F9, offset: 0x78E38, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgACIeyByy_SSSgADIeggg_TR', symObjAddr: 0x8B4, symBinAddr: 0x8A44, symSize: 0x78 }
-  - { offsetInCU: 0x1A11, offset: 0x78E50, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgSo6NSDataCSgIeyByy_SSSgAFIeggg_TR', symObjAddr: 0xBB4, symBinAddr: 0x8D44, symSize: 0x54 }
-  - { offsetInCU: 0x1A7E, offset: 0x78EBD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCfETo', symObjAddr: 0x1464, symBinAddr: 0x95F4, symSize: 0x4 }
-  - { offsetInCU: 0x1B09, offset: 0x78F48, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCMa', symObjAddr: 0x2604, symBinAddr: 0xA794, symSize: 0x20 }
-  - { offsetInCU: 0x1B1D, offset: 0x78F5C, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgACIeyByy_SSSgADIeggg_TRTA', symObjAddr: 0x2648, symBinAddr: 0xA7D8, symSize: 0x8 }
-  - { offsetInCU: 0x1B3C, offset: 0x78F7B, size: 0x8, addend: 0x0, symName: '_$sSo7NSErrorCSg10ObjectiveC8ObjCBoolVIeyByy_ACSbIeggy_TRTA', symObjAddr: 0x2650, symBinAddr: 0xA7E0, symSize: 0x18 }
-  - { offsetInCU: 0x1B65, offset: 0x78FA4, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgSo6NSDataCSgIeyByy_SSSgAFIeggg_TRTA', symObjAddr: 0x2668, symBinAddr: 0xA7F8, symSize: 0x8 }
-  - { offsetInCU: 0x1B79, offset: 0x78FB8, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCMa', symObjAddr: 0x2670, symBinAddr: 0xA800, symSize: 0x3C }
-  - { offsetInCU: 0x1B8D, offset: 0x78FCC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZyyYbcfU_TA', symObjAddr: 0x26F0, symBinAddr: 0xA880, symSize: 0x34 }
-  - { offsetInCU: 0x1BA1, offset: 0x78FE0, size: 0x8, addend: 0x0, symName: _block_copy_helper, symObjAddr: 0x2724, symBinAddr: 0xA8B4, symSize: 0x10 }
-  - { offsetInCU: 0x1BB5, offset: 0x78FF4, size: 0x8, addend: 0x0, symName: _block_destroy_helper, symObjAddr: 0x2734, symBinAddr: 0xA8C4, symSize: 0x8 }
-  - { offsetInCU: 0x1BC9, offset: 0x79008, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZyyYbcfU_yyYbcfU0_TA', symObjAddr: 0x2760, symBinAddr: 0xA8F0, symSize: 0x40 }
-  - { offsetInCU: 0x1BFD, offset: 0x7903C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZyyYbcfU_yyYbcfU0_TA', symObjAddr: 0x27E4, symBinAddr: 0xA974, symSize: 0x40 }
-  - { offsetInCU: 0x1C3B, offset: 0x7907A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZyyYbcfU_yyYbcfU_TA', symObjAddr: 0x2824, symBinAddr: 0xA9B4, symSize: 0x28 }
-  - { offsetInCU: 0x1C6F, offset: 0x790AE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZyyYbcfU_yyYbcfU_TA', symObjAddr: 0x28A4, symBinAddr: 0xAA34, symSize: 0x3C }
-  - { offsetInCU: 0x1CA3, offset: 0x790E2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZyyYbcfU_yyYbcfU0_TA', symObjAddr: 0x290C, symBinAddr: 0xAA9C, symSize: 0x30 }
-  - { offsetInCU: 0x1CDF, offset: 0x7911E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZyyYbcfU_TA', symObjAddr: 0x2978, symBinAddr: 0xAB08, symSize: 0x10 }
-  - { offsetInCU: 0x1CF3, offset: 0x79132, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZyyYbcfU_yyYbcfU_TA', symObjAddr: 0x2988, symBinAddr: 0xAB18, symSize: 0x40 }
-  - { offsetInCU: 0x21C0, offset: 0x795FF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC19getBytesFromUIImageySo13NSMutableDataCSo0G0CFZ', symObjAddr: 0x0, symBinAddr: 0x8190, symSize: 0x4 }
-  - { offsetInCU: 0x21DB, offset: 0x7961A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x3C, symBinAddr: 0x81CC, symSize: 0x4 }
-  - { offsetInCU: 0x21F6, offset: 0x79635, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC25loadImageAssetWithContextySbs5Int64V_So7UIImageCtFZ', symObjAddr: 0xB0, symBinAddr: 0x8240, symSize: 0x4 }
-  - { offsetInCU: 0x2217, offset: 0x79656, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dyys5Int64V_So7UIImageCS2ftFZ', symObjAddr: 0xF8, symBinAddr: 0x8288, symSize: 0x4 }
-  - { offsetInCU: 0x2232, offset: 0x79671, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dy2dw2dhys5Int64V_So7UIImageCS4ftFZ', symObjAddr: 0x14C, symBinAddr: 0x82DC, symSize: 0x4 }
-  - { offsetInCU: 0x224D, offset: 0x7968C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2sx2sy2sw2sh2dx2dy2dw2dhys5Int64V_So7UIImageCS8ftFZ', symObjAddr: 0x1B8, symBinAddr: 0x8348, symSize: 0x4 }
-  - { offsetInCU: 0x2268, offset: 0x796A7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23initWebGPUWithViewLayerys5Int64VAF_AFs6UInt32VAHtFZ', symObjAddr: 0x254, symBinAddr: 0x83E4, symSize: 0x4 }
-  - { offsetInCU: 0x22F6, offset: 0x79735, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC18initWebGPUWithViewys5Int64VAF_AFs6UInt32VAHtFZ', symObjAddr: 0x26C, symBinAddr: 0x83FC, symSize: 0x4 }
-  - { offsetInCU: 0x2375, offset: 0x797B4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14initGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbtFZ', symObjAddr: 0x284, symBinAddr: 0x8414, symSize: 0x44 }
-  - { offsetInCU: 0x24B3, offset: 0x798F2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC20initSharedGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbAFtFZ', symObjAddr: 0x318, symBinAddr: 0x84A8, symSize: 0x4C }
-  - { offsetInCU: 0x25FC, offset: 0x79A3B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC24initGLWithWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbtFZ', symObjAddr: 0x3BC, symBinAddr: 0x854C, symSize: 0x48 }
-  - { offsetInCU: 0x2744, offset: 0x79B83, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC26initSharedGLWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbAFtFZ', symObjAddr: 0x45C, symBinAddr: 0x85EC, symSize: 0x50 }
-  - { offsetInCU: 0x28A1, offset: 0x79CE0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15resize2DContextyys5Int64V_S2ftFZ', symObjAddr: 0x50C, symBinAddr: 0x869C, symSize: 0x4 }
-  - { offsetInCU: 0x2913, offset: 0x79D52, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14flush2DContextyys5Int64VFZ', symObjAddr: 0x518, symBinAddr: 0x86A8, symSize: 0x4 }
-  - { offsetInCU: 0x2956, offset: 0x79D95, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC7flushGLySbs5Int64VFZ', symObjAddr: 0x524, symBinAddr: 0x86B4, symSize: 0x14 }
-  - { offsetInCU: 0x299B, offset: 0x79DDA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9releaseGLyys5Int64VFZ', symObjAddr: 0x540, symBinAddr: 0x86D0, symSize: 0x4 }
-  - { offsetInCU: 0x29DE, offset: 0x79E1D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC12getGLPointerys5Int64VAFFZ', symObjAddr: 0x54C, symBinAddr: 0x86DC, symSize: 0x4 }
-  - { offsetInCU: 0x2A21, offset: 0x79E60, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC16releaseGLPointeryys5Int64VFZ', symObjAddr: 0x558, symBinAddr: 0x86E8, symSize: 0x4 }
-  - { offsetInCU: 0x2A64, offset: 0x79EA3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15create2DContextys5Int64VAF_s5Int32VAHSbSfA2HSfAHtFZ', symObjAddr: 0x564, symBinAddr: 0x86F4, symSize: 0x8 }
-  - { offsetInCU: 0x2B4B, offset: 0x79F8A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23updateGLSurfaceWithViewyys5Int64V_s5Int32VAhFtFZ', symObjAddr: 0x590, symBinAddr: 0x8720, symSize: 0x4 }
-  - { offsetInCU: 0x2BCA, offset: 0x7A009, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC6test2Dyys5Int64VFZ', symObjAddr: 0x5A8, symBinAddr: 0x8738, symSize: 0x4 }
-  - { offsetInCU: 0x2C0D, offset: 0x7A04C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13testToDataURLySSs5Int64VFZ', symObjAddr: 0x5B4, symBinAddr: 0x8744, symSize: 0x58 }
-  - { offsetInCU: 0x2CCE, offset: 0x7A10D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZ', symObjAddr: 0x680, symBinAddr: 0x8810, symSize: 0x4 }
-  - { offsetInCU: 0x2CE2, offset: 0x7A121, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZyyYbcfU_', symObjAddr: 0x684, symBinAddr: 0x8814, symSize: 0x190 }
-  - { offsetInCU: 0x2D82, offset: 0x7A1C1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZ', symObjAddr: 0x92C, symBinAddr: 0x8ABC, symSize: 0x2C }
-  - { offsetInCU: 0x2D96, offset: 0x7A1D5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZyyYbcfU_', symObjAddr: 0x958, symBinAddr: 0x8AE8, symSize: 0x1C4 }
-  - { offsetInCU: 0x2E80, offset: 0x7A2BF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZ', symObjAddr: 0xC08, symBinAddr: 0x8D98, symSize: 0x2C }
-  - { offsetInCU: 0x2E94, offset: 0x7A2D3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZyyYbcfU_', symObjAddr: 0xC34, symBinAddr: 0x8DC4, symSize: 0x23C }
-  - { offsetInCU: 0x2F48, offset: 0x7A387, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZ', symObjAddr: 0xF08, symBinAddr: 0x9098, symSize: 0x4 }
-  - { offsetInCU: 0x2F5C, offset: 0x7A39B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZyyYbcfU_', symObjAddr: 0xF0C, symBinAddr: 0x909C, symSize: 0x38C }
-  - { offsetInCU: 0x31F3, offset: 0x7A632, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC32getPixelsPerInchForCurrentDeviceSSyFZ', symObjAddr: 0x1370, symBinAddr: 0x9500, symSize: 0x4 }
-  - { offsetInCU: 0x320E, offset: 0x7A64D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCACycfC', symObjAddr: 0x13A8, symBinAddr: 0x9538, symSize: 0x20 }
-  - { offsetInCU: 0x3222, offset: 0x7A661, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCACycfc', symObjAddr: 0x13C8, symBinAddr: 0x9558, symSize: 0x30 }
-  - { offsetInCU: 0x3258, offset: 0x7A697, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCfD', symObjAddr: 0x1434, symBinAddr: 0x95C4, symSize: 0x30 }
-  - { offsetInCU: 0x4F, offset: 0x7A8CF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19shared_context_view33_508084857CA7D194CA72FEB80DD78002LLSo7GLKViewCvpZ', symObjAddr: 0x55E0, symBinAddr: 0x10D39E0, symSize: 0x0 }
-  - { offsetInCU: 0x69, offset: 0x7A8E9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15_shared_context33_508084857CA7D194CA72FEB80DD78002LLs5Int64VvpZ', symObjAddr: 0x55E8, symBinAddr: 0x10D39E8, symSize: 0x0 }
-  - { offsetInCU: 0x83, offset: 0x7A903, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5storeSo19NSMutableDictionaryCvpZ', symObjAddr: 0x55F0, symBinAddr: 0x10D39F0, symSize: 0x0 }
-  - { offsetInCU: 0x9D, offset: 0x7A91D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5views33_508084857CA7D194CA72FEB80DD78002LLSo10NSMapTableCySo8NSStringCACGvpZ', symObjAddr: 0x55F8, symBinAddr: 0x10D39F8, symSize: 0x0 }
-  - { offsetInCU: 0xAB, offset: 0x7A92B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19shared_context_view33_508084857CA7D194CA72FEB80DD78002LL_WZ', symObjAddr: 0x0, symBinAddr: 0xAC40, symSize: 0x40 }
-  - { offsetInCU: 0xF0, offset: 0x7A970, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5store_WZ', symObjAddr: 0x40, symBinAddr: 0xAC80, symSize: 0x30 }
-  - { offsetInCU: 0x135, offset: 0x7A9B5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5views33_508084857CA7D194CA72FEB80DD78002LL_WZ', symObjAddr: 0xA8, symBinAddr: 0xACE8, symSize: 0x40 }
-  - { offsetInCU: 0x187, offset: 0x7AA07, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC3ptrSvSgvgTo', symObjAddr: 0x194, symBinAddr: 0xADD4, symSize: 0x10 }
-  - { offsetInCU: 0x1A7, offset: 0x7AA27, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC3ptrSvSgvgTo', symObjAddr: 0x194, symBinAddr: 0xADD4, symSize: 0x10 }
-  - { offsetInCU: 0x1DD, offset: 0x7AA5D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC3ptrSvSgvsTo', symObjAddr: 0x1A4, symBinAddr: 0xADE4, symSize: 0x10 }
-  - { offsetInCU: 0x1FD, offset: 0x7AA7D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC3ptrSvSgvsTo', symObjAddr: 0x1A4, symBinAddr: 0xADE4, symSize: 0x10 }
-  - { offsetInCU: 0x236, offset: 0x7AAB6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6mtlPtrSvSgvgTo', symObjAddr: 0x1B4, symBinAddr: 0xADF4, symSize: 0x10 }
-  - { offsetInCU: 0x256, offset: 0x7AAD6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6mtlPtrSvSgvgTo', symObjAddr: 0x1B4, symBinAddr: 0xADF4, symSize: 0x10 }
-  - { offsetInCU: 0x28C, offset: 0x7AB0C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6mtlPtrSvSgvsTo', symObjAddr: 0x1C4, symBinAddr: 0xAE04, symSize: 0x10 }
-  - { offsetInCU: 0x2AC, offset: 0x7AB2C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6mtlPtrSvSgvsTo', symObjAddr: 0x1C4, symBinAddr: 0xAE04, symSize: 0x10 }
-  - { offsetInCU: 0x2E5, offset: 0x7AB65, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvgTo', symObjAddr: 0x29C, symBinAddr: 0xAEDC, symSize: 0x44 }
-  - { offsetInCU: 0x322, offset: 0x7ABA2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvsTo', symObjAddr: 0x324, symBinAddr: 0xAF64, symSize: 0x30 }
-  - { offsetInCU: 0x3B1, offset: 0x7AC31, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8nativeGLs5Int64VvgTo', symObjAddr: 0x578, symBinAddr: 0xB1B8, symSize: 0x44 }
-  - { offsetInCU: 0x409, offset: 0x7AC89, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8nativeGLs5Int64VvsTo', symObjAddr: 0x600, symBinAddr: 0xB240, symSize: 0x48 }
-  - { offsetInCU: 0x464, offset: 0x7ACE4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13nativeContexts5Int64VvgTo', symObjAddr: 0x648, symBinAddr: 0xB288, symSize: 0x44 }
-  - { offsetInCU: 0x4BC, offset: 0x7AD3C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13nativeContexts5Int64VvsTo', symObjAddr: 0x6D0, symBinAddr: 0xB310, symSize: 0x48 }
-  - { offsetInCU: 0x517, offset: 0x7AD97, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15native2DContexts5Int64VvgTo', symObjAddr: 0x718, symBinAddr: 0xB358, symSize: 0x10 }
-  - { offsetInCU: 0x537, offset: 0x7ADB7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15native2DContexts5Int64VvgTo', symObjAddr: 0x718, symBinAddr: 0xB358, symSize: 0x10 }
-  - { offsetInCU: 0x56D, offset: 0x7ADED, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15native2DContexts5Int64VvsTo', symObjAddr: 0x728, symBinAddr: 0xB368, symSize: 0x10 }
-  - { offsetInCU: 0x58D, offset: 0x7AE0D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15native2DContexts5Int64VvsTo', symObjAddr: 0x728, symBinAddr: 0xB368, symSize: 0x10 }
-  - { offsetInCU: 0x5C6, offset: 0x7AE46, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7mtlViewSo7MTKViewCvgTo', symObjAddr: 0x738, symBinAddr: 0xB378, symSize: 0x10 }
-  - { offsetInCU: 0x5E6, offset: 0x7AE66, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7mtlViewSo7MTKViewCvgTo', symObjAddr: 0x738, symBinAddr: 0xB378, symSize: 0x10 }
-  - { offsetInCU: 0x61E, offset: 0x7AE9E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7mtlViewSo7MTKViewCvsTo', symObjAddr: 0x748, symBinAddr: 0xB388, symSize: 0x34 }
-  - { offsetInCU: 0x677, offset: 0x7AEF7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7glkViewAA0A7GLKViewCvgTo', symObjAddr: 0x77C, symBinAddr: 0xB3BC, symSize: 0x10 }
-  - { offsetInCU: 0x697, offset: 0x7AF17, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7glkViewAA0A7GLKViewCvgTo', symObjAddr: 0x77C, symBinAddr: 0xB3BC, symSize: 0x10 }
-  - { offsetInCU: 0x6CF, offset: 0x7AF4F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7glkViewAA0A7GLKViewCvsTo', symObjAddr: 0x78C, symBinAddr: 0xB3CC, symSize: 0x34 }
-  - { offsetInCU: 0x728, offset: 0x7AFA8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC4is2DSbvgTo', symObjAddr: 0x7C0, symBinAddr: 0xB400, symSize: 0x10 }
-  - { offsetInCU: 0x748, offset: 0x7AFC8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC4is2DSbvgTo', symObjAddr: 0x7C0, symBinAddr: 0xB400, symSize: 0x10 }
-  - { offsetInCU: 0x77E, offset: 0x7AFFE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC4is2DSbvsTo', symObjAddr: 0x7D0, symBinAddr: 0xB410, symSize: 0x10 }
-  - { offsetInCU: 0x79E, offset: 0x7B01E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC4is2DSbvsTo', symObjAddr: 0x7D0, symBinAddr: 0xB410, symSize: 0x10 }
-  - { offsetInCU: 0x7D7, offset: 0x7B057, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7isMetalSbvgTo', symObjAddr: 0x7E0, symBinAddr: 0xB420, symSize: 0x10 }
-  - { offsetInCU: 0x7F7, offset: 0x7B077, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7isMetalSbvgTo', symObjAddr: 0x7E0, symBinAddr: 0xB420, symSize: 0x10 }
-  - { offsetInCU: 0x82D, offset: 0x7B0AD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7isMetalSbvsTo', symObjAddr: 0x7F0, symBinAddr: 0xB430, symSize: 0x10 }
-  - { offsetInCU: 0x84D, offset: 0x7B0CD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7isMetalSbvsTo', symObjAddr: 0x7F0, symBinAddr: 0xB430, symSize: 0x10 }
-  - { offsetInCU: 0x870, offset: 0x7B0F0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18drawingBufferWidthSivgTo', symObjAddr: 0x800, symBinAddr: 0xB440, symSize: 0x34 }
-  - { offsetInCU: 0x8A2, offset: 0x7B122, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19drawingBufferHeightSivgTo', symObjAddr: 0x904, symBinAddr: 0xB544, symSize: 0x34 }
-  - { offsetInCU: 0x8EA, offset: 0x7B16A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5widthSfvgTo', symObjAddr: 0xA08, symBinAddr: 0xB648, symSize: 0x20 }
-  - { offsetInCU: 0x952, offset: 0x7B1D2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6heightSfvgTo', symObjAddr: 0xA4C, symBinAddr: 0xB68C, symSize: 0x20 }
-  - { offsetInCU: 0x9F1, offset: 0x7B271, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11initContextyySS_S4bs5Int32VS5btFTo', symObjAddr: 0xAB4, symBinAddr: 0xB6F4, symSize: 0xC4 }
-  - { offsetInCU: 0xAB4, offset: 0x7B334, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17initWebGPUContextyys5Int64VFTo', symObjAddr: 0xD10, symBinAddr: 0xB950, symSize: 0x30 }
-  - { offsetInCU: 0xB64, offset: 0x7B3E4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC015initContextWithE10AttributesyySS_S4bs5Int32VS5btFTo', symObjAddr: 0x15C8, symBinAddr: 0xC208, symSize: 0xC4 }
-  - { offsetInCU: 0xBCE, offset: 0x7B44E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15create2DContextys5Int64VSb_S3bs5Int32VS5bAHtFTo', symObjAddr: 0x18E4, symBinAddr: 0xC524, symSize: 0xB0 }
-  - { offsetInCU: 0xC0B, offset: 0x7B48B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11forceLayoutyy12CoreGraphics7CGFloatV_AGtFTo', symObjAddr: 0x1A54, symBinAddr: 0xC694, symSize: 0xB8 }
-  - { offsetInCU: 0xC83, offset: 0x7B503, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8snapshotySo7UIImageCSgSbFTo', symObjAddr: 0x1BF0, symBinAddr: 0xC830, symSize: 0x3C }
-  - { offsetInCU: 0xCB6, offset: 0x7B536, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8rendererAA9NSCRenderCSgvgTo', symObjAddr: 0x1C2C, symBinAddr: 0xC86C, symSize: 0x10 }
-  - { offsetInCU: 0xCD6, offset: 0x7B556, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8rendererAA9NSCRenderCSgvgTo', symObjAddr: 0x1C2C, symBinAddr: 0xC86C, symSize: 0x10 }
-  - { offsetInCU: 0xD10, offset: 0x7B590, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8rendererAA9NSCRenderCSgvsTo', symObjAddr: 0x1C3C, symBinAddr: 0xC87C, symSize: 0x34 }
-  - { offsetInCU: 0xD6B, offset: 0x7B5EB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6renderSbyFTo', symObjAddr: 0x1CB8, symBinAddr: 0xC8F8, symSize: 0x48 }
-  - { offsetInCU: 0xE05, offset: 0x7B685, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13context2DTestyys5Int64VFTo', symObjAddr: 0x1D4C, symBinAddr: 0xC98C, symSize: 0x64 }
-  - { offsetInCU: 0xECA, offset: 0x7B74A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC22context2DTestToDataURLySSs5Int64VFTo', symObjAddr: 0x1E08, symBinAddr: 0xCA48, symSize: 0x94 }
-  - { offsetInCU: 0xF57, offset: 0x7B7D7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC23enterBackgroundListeneryycSgvsTo', symObjAddr: 0x1EDC, symBinAddr: 0xCB1C, symSize: 0x6C }
-  - { offsetInCU: 0xFB9, offset: 0x7B839, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC20becomeActiveListeneryycSgvsTo', symObjAddr: 0x1FEC, symBinAddr: 0xCC2C, symSize: 0x6C }
-  - { offsetInCU: 0x1016, offset: 0x7B896, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvgTo', symObjAddr: 0x2058, symBinAddr: 0xCC98, symSize: 0xB0 }
-  - { offsetInCU: 0x1068, offset: 0x7B8E8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvsTo', symObjAddr: 0x21D8, symBinAddr: 0xCE18, symSize: 0x94 }
-  - { offsetInCU: 0x10FA, offset: 0x7B97A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5coderACSgSo7NSCoderC_tcfcTo', symObjAddr: 0x2EC4, symBinAddr: 0xDB04, symSize: 0x28 }
-  - { offsetInCU: 0x114F, offset: 0x7B9CF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5frameACSo6CGRectV_tcfcTo', symObjAddr: 0x3944, symBinAddr: 0xE584, symSize: 0x20 }
-  - { offsetInCU: 0x1182, offset: 0x7BA02, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvgTo', symObjAddr: 0x3964, symBinAddr: 0xE5A4, symSize: 0x10 }
-  - { offsetInCU: 0x11A2, offset: 0x7BA22, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvgTo', symObjAddr: 0x3964, symBinAddr: 0xE5A4, symSize: 0x10 }
-  - { offsetInCU: 0x11DA, offset: 0x7BA5A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvsTo', symObjAddr: 0x3974, symBinAddr: 0xE5B4, symSize: 0x34 }
-  - { offsetInCU: 0x1248, offset: 0x7BAC8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13readyListenerAA0cE0_pSgvgTo', symObjAddr: 0x3A28, symBinAddr: 0xE668, symSize: 0x20 }
-  - { offsetInCU: 0x12A2, offset: 0x7BB22, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13readyListenerAA0cE0_pSgvsTo', symObjAddr: 0x3A48, symBinAddr: 0xE688, symSize: 0x34 }
-  - { offsetInCU: 0x1302, offset: 0x7BB82, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11setListeneryyAA0cE0_pSgFTo', symObjAddr: 0x3AAC, symBinAddr: 0xE6EC, symSize: 0x34 }
-  - { offsetInCU: 0x1446, offset: 0x7BCC6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC14layoutSubviewsyyFTo', symObjAddr: 0x3DF8, symBinAddr: 0xEA38, symSize: 0x28 }
-  - { offsetInCU: 0x1479, offset: 0x7BCF9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCfDTo', symObjAddr: 0x4124, symBinAddr: 0xED64, symSize: 0x24 }
-  - { offsetInCU: 0x14B4, offset: 0x7BD34, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC21getBoundingClientRectyySo6UIViewC_SvtFZTo', symObjAddr: 0x4210, symBinAddr: 0xEE50, symSize: 0x34 }
-  - { offsetInCU: 0x14E7, offset: 0x7BD67, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC14shared_context33_508084857CA7D194CA72FEB80DD78002LLs5Int64VvgZTf4d_n', symObjAddr: 0x4BAC, symBinAddr: 0xF7EC, symSize: 0x2A8 }
-  - { offsetInCU: 0x1664, offset: 0x7BEE4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC21getBoundingClientRectyySo6UIViewC_SvtFZTf4nnd_n', symObjAddr: 0x4F18, symBinAddr: 0xFB58, symSize: 0xA0 }
-  - { offsetInCU: 0x18E0, offset: 0x7C160, size: 0x8, addend: 0x0, symName: '_$sIeg_IeyB_TR', symObjAddr: 0x1EB0, symBinAddr: 0xCAF0, symSize: 0x2C }
-  - { offsetInCU: 0x18F8, offset: 0x7C178, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_So8NSStringCABIeyByy_TR', symObjAddr: 0x2160, symBinAddr: 0xCDA0, symSize: 0x78 }
-  - { offsetInCU: 0x1910, offset: 0x7C190, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvpACTK', symObjAddr: 0x22C8, symBinAddr: 0xCF08, symSize: 0x94 }
-  - { offsetInCU: 0x1948, offset: 0x7C1C8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvpACTk', symObjAddr: 0x235C, symBinAddr: 0xCF9C, symSize: 0xB8 }
-  - { offsetInCU: 0x198A, offset: 0x7C20A, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCytIegnnr_SSABIeggg_TR', symObjAddr: 0x2414, symBinAddr: 0xD054, symSize: 0x6C }
-  - { offsetInCU: 0x1A3A, offset: 0x7C2BA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCfETo', symObjAddr: 0x4148, symBinAddr: 0xED88, symSize: 0xC4 }
-  - { offsetInCU: 0x1A6A, offset: 0x7C2EA, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_SgWOy', symObjAddr: 0x4244, symBinAddr: 0xEE84, symSize: 0x10 }
-  - { offsetInCU: 0x1A7E, offset: 0x7C2FE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCMa', symObjAddr: 0x4254, symBinAddr: 0xEE94, symSize: 0x20 }
-  - { offsetInCU: 0x1A92, offset: 0x7C312, size: 0x8, addend: 0x0, symName: '_$ss29getContiguousArrayStorageType3fors01_bcD0CyxGmxm_tlFSo18NSLayoutConstraintC_Tgm5', symObjAddr: 0x4274, symBinAddr: 0xEEB4, symSize: 0x64 }
-  - { offsetInCU: 0x1C99, offset: 0x7C519, size: 0x8, addend: 0x0, symName: ___swift_instantiateConcreteTypeFromMangledName, symObjAddr: 0x4E54, symBinAddr: 0xFA94, symSize: 0x40 }
-  - { offsetInCU: 0x1CAD, offset: 0x7C52D, size: 0x8, addend: 0x0, symName: '_$sypSgWOh', symObjAddr: 0x4E94, symBinAddr: 0xFAD4, symSize: 0x40 }
-  - { offsetInCU: 0x1CC1, offset: 0x7C541, size: 0x8, addend: 0x0, symName: ___swift_project_boxed_opaque_existential_0, symObjAddr: 0x4ED4, symBinAddr: 0xFB14, symSize: 0x24 }
-  - { offsetInCU: 0x1CD5, offset: 0x7C555, size: 0x8, addend: 0x0, symName: ___swift_destroy_boxed_opaque_existential_0, symObjAddr: 0x4EF8, symBinAddr: 0xFB38, symSize: 0x20 }
-  - { offsetInCU: 0x1CF4, offset: 0x7C574, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSo19UIGestureRecognizerCIeyByy_SSADIeggg_TRTA', symObjAddr: 0x53E4, symBinAddr: 0x10024, symSize: 0x48 }
-  - { offsetInCU: 0x1D1D, offset: 0x7C59D, size: 0x8, addend: 0x0, symName: _block_copy_helper, symObjAddr: 0x542C, symBinAddr: 0x1006C, symSize: 0x10 }
-  - { offsetInCU: 0x1D31, offset: 0x7C5B1, size: 0x8, addend: 0x0, symName: _block_destroy_helper, symObjAddr: 0x543C, symBinAddr: 0x1007C, symSize: 0x8 }
-  - { offsetInCU: 0x1D45, offset: 0x7C5C5, size: 0x8, addend: 0x0, symName: '_$sIeg_SgWOe', symObjAddr: 0x5444, symBinAddr: 0x10084, symSize: 0x10 }
-  - { offsetInCU: 0x1D64, offset: 0x7C5E4, size: 0x8, addend: 0x0, symName: '_$sIeyB_Ieg_TRTA', symObjAddr: 0x5454, symBinAddr: 0x10094, symSize: 0xC }
-  - { offsetInCU: 0x1D8D, offset: 0x7C60D, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCytIegnnr_SSABIeggg_TRTA', symObjAddr: 0x5484, symBinAddr: 0x100C4, symSize: 0x8 }
-  - { offsetInCU: 0x1DAC, offset: 0x7C62C, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_SSABytIegnnr_TRTA', symObjAddr: 0x548C, symBinAddr: 0x100CC, symSize: 0x30 }
-  - { offsetInCU: 0x1DD5, offset: 0x7C655, size: 0x8, addend: 0x0, symName: '_$sypWOb', symObjAddr: 0x54BC, symBinAddr: 0x100FC, symSize: 0x10 }
-  - { offsetInCU: 0x1DE9, offset: 0x7C669, size: 0x8, addend: 0x0, symName: '_$sypWOc', symObjAddr: 0x5504, symBinAddr: 0x10144, symSize: 0x3C }
-  - { offsetInCU: 0x206E, offset: 0x7C8EE, size: 0x8, addend: 0x0, symName: '_$sSD17dictionaryLiteralSDyxq_Gx_q_td_tcfCSS_ypTgm5Tf4g_n', symObjAddr: 0x4A94, symBinAddr: 0xF6D4, symSize: 0x118 }
-  - { offsetInCU: 0x2514, offset: 0x7CD94, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvg', symObjAddr: 0x2E0, symBinAddr: 0xAF20, symSize: 0x44 }
-  - { offsetInCU: 0x2547, offset: 0x7CDC7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvs', symObjAddr: 0x354, symBinAddr: 0xAF94, symSize: 0xEC }
-  - { offsetInCU: 0x2593, offset: 0x7CE13, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvM', symObjAddr: 0x440, symBinAddr: 0xB080, symSize: 0x58 }
-  - { offsetInCU: 0x25B8, offset: 0x7CE38, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvM.resume.0', symObjAddr: 0x498, symBinAddr: 0xB0D8, symSize: 0xE0 }
-  - { offsetInCU: 0x25F9, offset: 0x7CE79, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8nativeGLs5Int64Vvg', symObjAddr: 0x5BC, symBinAddr: 0xB1FC, symSize: 0x44 }
-  - { offsetInCU: 0x2651, offset: 0x7CED1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13nativeContexts5Int64Vvg', symObjAddr: 0x68C, symBinAddr: 0xB2CC, symSize: 0x44 }
-  - { offsetInCU: 0x27BF, offset: 0x7D03F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18drawingBufferWidthSivg', symObjAddr: 0x834, symBinAddr: 0xB474, symSize: 0xD0 }
-  - { offsetInCU: 0x28E4, offset: 0x7D164, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19drawingBufferHeightSivg', symObjAddr: 0x938, symBinAddr: 0xB578, symSize: 0xD0 }
-  - { offsetInCU: 0x2A2A, offset: 0x7D2AA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5widthSfvg', symObjAddr: 0xA28, symBinAddr: 0xB668, symSize: 0x24 }
-  - { offsetInCU: 0x2A72, offset: 0x7D2F2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6heightSfvg', symObjAddr: 0xA6C, symBinAddr: 0xB6AC, symSize: 0x24 }
-  - { offsetInCU: 0x2AA6, offset: 0x7D326, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11initContextyySS_S4bs5Int32VS5btF', symObjAddr: 0xA90, symBinAddr: 0xB6D0, symSize: 0x24 }
-  - { offsetInCU: 0x2C34, offset: 0x7D4B4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17initWebGPUContextyys5Int64VF', symObjAddr: 0xB78, symBinAddr: 0xB7B8, symSize: 0x198 }
-  - { offsetInCU: 0x3027, offset: 0x7D8A7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC015initContextWithE10AttributesyySS_S4bs5Int32VS5btF', symObjAddr: 0xD40, symBinAddr: 0xB980, symSize: 0x888 }
-  - { offsetInCU: 0x382A, offset: 0x7E0AA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15create2DContextys5Int64VSb_S3bs5Int32VS5bAHtF', symObjAddr: 0x168C, symBinAddr: 0xC2CC, symSize: 0x258 }
-  - { offsetInCU: 0x3C5C, offset: 0x7E4DC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11forceLayoutyy12CoreGraphics7CGFloatV_AGtF', symObjAddr: 0x1994, symBinAddr: 0xC5D4, symSize: 0xC0 }
-  - { offsetInCU: 0x3CED, offset: 0x7E56D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8snapshotySo7UIImageCSgSbF', symObjAddr: 0x1B0C, symBinAddr: 0xC74C, symSize: 0xE4 }
-  - { offsetInCU: 0x3E48, offset: 0x7E6C8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6renderSbyF', symObjAddr: 0x1C70, symBinAddr: 0xC8B0, symSize: 0x48 }
-  - { offsetInCU: 0x3ECE, offset: 0x7E74E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13context2DTestyys5Int64VF', symObjAddr: 0x1D00, symBinAddr: 0xC940, symSize: 0x4C }
-  - { offsetInCU: 0x3FEF, offset: 0x7E86F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC22context2DTestToDataURLySSs5Int64VF', symObjAddr: 0x1DB0, symBinAddr: 0xC9F0, symSize: 0x58 }
-  - { offsetInCU: 0x40E5, offset: 0x7E965, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvg', symObjAddr: 0x2108, symBinAddr: 0xCD48, symSize: 0x58 }
-  - { offsetInCU: 0x4131, offset: 0x7E9B1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvs', symObjAddr: 0x226C, symBinAddr: 0xCEAC, symSize: 0x5C }
-  - { offsetInCU: 0x415A, offset: 0x7E9DA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvM', symObjAddr: 0x2480, symBinAddr: 0xD0C0, symSize: 0x44 }
-  - { offsetInCU: 0x4180, offset: 0x7EA00, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvM.resume.0', symObjAddr: 0x24C4, symBinAddr: 0xD104, symSize: 0x4 }
-  - { offsetInCU: 0x4242, offset: 0x7EAC2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5coderACSgSo7NSCoderC_tcfc', symObjAddr: 0x24C8, symBinAddr: 0xD108, symSize: 0x9FC }
-  - { offsetInCU: 0x4465, offset: 0x7ECE5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5frameACSo6CGRectV_tcfC', symObjAddr: 0x2EEC, symBinAddr: 0xDB2C, symSize: 0x50 }
-  - { offsetInCU: 0x448E, offset: 0x7ED0E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5frameACSo6CGRectV_tcfc', symObjAddr: 0x2F3C, symBinAddr: 0xDB7C, symSize: 0xA08 }
-  - { offsetInCU: 0x46D2, offset: 0x7EF52, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvW', symObjAddr: 0x39A8, symBinAddr: 0xE5E8, symSize: 0x80 }
-  - { offsetInCU: 0x47C8, offset: 0x7F048, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11setListeneryyAA0cE0_pSgF', symObjAddr: 0x3A7C, symBinAddr: 0xE6BC, symSize: 0x30 }
-  - { offsetInCU: 0x4866, offset: 0x7F0E6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6resize33_508084857CA7D194CA72FEB80DD78002LLyyF', symObjAddr: 0x3AE0, symBinAddr: 0xE720, symSize: 0x144 }
-  - { offsetInCU: 0x4A67, offset: 0x7F2E7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC14layoutSubviewsyyF', symObjAddr: 0x3C24, symBinAddr: 0xE864, symSize: 0x1D4 }
-  - { offsetInCU: 0x4CE4, offset: 0x7F564, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCfD', symObjAddr: 0x3E20, symBinAddr: 0xEA60, symSize: 0x304 }
-  - { offsetInCU: 0x4D74, offset: 0x7F5F4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC21getBoundingClientRectyySo6UIViewC_SvtFZ', symObjAddr: 0x420C, symBinAddr: 0xEE4C, symSize: 0x4 }
-  - { offsetInCU: 0x4D9C, offset: 0x7F61C, size: 0x8, addend: 0x0, symName: '_$ss22__RawDictionaryStorageC4findys10_HashTableV6BucketV6bucket_Sb5foundtxSHRzlFSS_Tg5', symObjAddr: 0x42D8, symBinAddr: 0xEF18, symSize: 0x64 }
-  - { offsetInCU: 0x4DF6, offset: 0x7F676, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV7_insert2at3key5valueys10_HashTableV6BucketV_xnq_ntFSS_ypTg5', symObjAddr: 0x433C, symBinAddr: 0xEF7C, symSize: 0x6C }
-  - { offsetInCU: 0x4E76, offset: 0x7F6F6, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV12mutatingFind_8isUniques10_HashTableV6BucketV6bucket_Sb5foundtx_SbtFSS_ypTg5', symObjAddr: 0x43A8, symBinAddr: 0xEFE8, symSize: 0xD8 }
-  - { offsetInCU: 0x4EB3, offset: 0x7F733, size: 0x8, addend: 0x0, symName: '_$ss22__RawDictionaryStorageC4find_9hashValues10_HashTableV6BucketV6bucket_Sb5foundtx_SitSHRzlFSS_Tg5', symObjAddr: 0x4480, symBinAddr: 0xF0C0, symSize: 0xE0 }
-  - { offsetInCU: 0x4F2E, offset: 0x7F7AE, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV4copyyyFSS_ypTg5', symObjAddr: 0x4560, symBinAddr: 0xF1A0, symSize: 0x1F4 }
-  - { offsetInCU: 0x4FEA, offset: 0x7F86A, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV20_copyOrMoveAndResize8capacity12moveElementsySi_SbtFSS_ypTg5', symObjAddr: 0x4754, symBinAddr: 0xF394, symSize: 0x340 }
-  - { offsetInCU: 0x27, offset: 0x7FAD2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative7GLUtilsCfD', symObjAddr: 0x0, symBinAddr: 0x101E4, symSize: 0x10 }
-  - { offsetInCU: 0x62, offset: 0x7FB0D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative7GLUtilsCMa', symObjAddr: 0x10, symBinAddr: 0x101F4, symSize: 0x20 }
-  - { offsetInCU: 0x1AF, offset: 0x7FC5A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative7GLUtilsCfD', symObjAddr: 0x0, symBinAddr: 0x101E4, symSize: 0x10 }
-  - { offsetInCU: 0x65, offset: 0x7FCE9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8mPrograms6UInt32VvgTo', symObjAddr: 0x0, symBinAddr: 0x10214, symSize: 0x10 }
-  - { offsetInCU: 0x85, offset: 0x7FD09, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8mPrograms6UInt32VvgTo', symObjAddr: 0x0, symBinAddr: 0x10214, symSize: 0x10 }
-  - { offsetInCU: 0xBB, offset: 0x7FD3F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8mPrograms6UInt32VvsTo', symObjAddr: 0x10, symBinAddr: 0x10224, symSize: 0x10 }
-  - { offsetInCU: 0xDB, offset: 0x7FD5F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8mPrograms6UInt32VvsTo', symObjAddr: 0x10, symBinAddr: 0x10224, symSize: 0x10 }
-  - { offsetInCU: 0x114, offset: 0x7FD98, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3rbos6UInt32VvgTo', symObjAddr: 0x20, symBinAddr: 0x10234, symSize: 0x44 }
-  - { offsetInCU: 0x16C, offset: 0x7FDF0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3rbos6UInt32VvsTo', symObjAddr: 0x64, symBinAddr: 0x10278, symSize: 0x48 }
-  - { offsetInCU: 0x1C7, offset: 0x7FE4B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3fbos6UInt32VvgTo', symObjAddr: 0xAC, symBinAddr: 0x102C0, symSize: 0x44 }
-  - { offsetInCU: 0x21F, offset: 0x7FEA3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3fbos6UInt32VvsTo', symObjAddr: 0xF0, symBinAddr: 0x10304, symSize: 0x48 }
-  - { offsetInCU: 0x27A, offset: 0x7FEFE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC5widthSivgTo', symObjAddr: 0x138, symBinAddr: 0x1034C, symSize: 0x10 }
-  - { offsetInCU: 0x29A, offset: 0x7FF1E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC5widthSivgTo', symObjAddr: 0x138, symBinAddr: 0x1034C, symSize: 0x10 }
-  - { offsetInCU: 0x2D0, offset: 0x7FF54, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC5widthSivsTo', symObjAddr: 0x148, symBinAddr: 0x1035C, symSize: 0x10 }
-  - { offsetInCU: 0x2F0, offset: 0x7FF74, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC5widthSivsTo', symObjAddr: 0x148, symBinAddr: 0x1035C, symSize: 0x10 }
-  - { offsetInCU: 0x329, offset: 0x7FFAD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC6heightSivgTo', symObjAddr: 0x158, symBinAddr: 0x1036C, symSize: 0x10 }
-  - { offsetInCU: 0x349, offset: 0x7FFCD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC6heightSivgTo', symObjAddr: 0x158, symBinAddr: 0x1036C, symSize: 0x10 }
-  - { offsetInCU: 0x37F, offset: 0x80003, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC6heightSivsTo', symObjAddr: 0x168, symBinAddr: 0x1037C, symSize: 0x10 }
-  - { offsetInCU: 0x39F, offset: 0x80023, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC6heightSivsTo', symObjAddr: 0x168, symBinAddr: 0x1037C, symSize: 0x10 }
-  - { offsetInCU: 0x3D8, offset: 0x8005C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC2abs6UInt32VvgTo', symObjAddr: 0x178, symBinAddr: 0x1038C, symSize: 0x44 }
-  - { offsetInCU: 0x430, offset: 0x800B4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC2abs6UInt32VvsTo', symObjAddr: 0x1BC, symBinAddr: 0x103D0, symSize: 0x48 }
-  - { offsetInCU: 0x48B, offset: 0x8010F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3poss5Int32VvgTo', symObjAddr: 0x204, symBinAddr: 0x10418, symSize: 0x10 }
-  - { offsetInCU: 0x4AB, offset: 0x8012F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3poss5Int32VvgTo', symObjAddr: 0x204, symBinAddr: 0x10418, symSize: 0x10 }
-  - { offsetInCU: 0x4E1, offset: 0x80165, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3poss5Int32VvsTo', symObjAddr: 0x214, symBinAddr: 0x10428, symSize: 0x10 }
-  - { offsetInCU: 0x501, offset: 0x80185, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3poss5Int32VvsTo', symObjAddr: 0x214, symBinAddr: 0x10428, symSize: 0x10 }
-  - { offsetInCU: 0x53A, offset: 0x801BE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10samplerPoss5Int32VvgTo', symObjAddr: 0x224, symBinAddr: 0x10438, symSize: 0x10 }
-  - { offsetInCU: 0x55A, offset: 0x801DE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10samplerPoss5Int32VvgTo', symObjAddr: 0x224, symBinAddr: 0x10438, symSize: 0x10 }
-  - { offsetInCU: 0x590, offset: 0x80214, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10samplerPoss5Int32VvsTo', symObjAddr: 0x234, symBinAddr: 0x10448, symSize: 0x10 }
-  - { offsetInCU: 0x5B0, offset: 0x80234, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10samplerPoss5Int32VvsTo', symObjAddr: 0x234, symBinAddr: 0x10448, symSize: 0x10 }
-  - { offsetInCU: 0x5E9, offset: 0x8026D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9vextexBufSaySfGvgTo', symObjAddr: 0x244, symBinAddr: 0x10458, symSize: 0x48 }
-  - { offsetInCU: 0x63F, offset: 0x802C3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9vextexBufSaySfGvsTo', symObjAddr: 0x28C, symBinAddr: 0x104A0, symSize: 0x40 }
-  - { offsetInCU: 0x682, offset: 0x80306, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13SIZE_OF_FLOATSivgZTo', symObjAddr: 0x2CC, symBinAddr: 0x104E0, symSize: 0x8 }
-  - { offsetInCU: 0x69E, offset: 0x80322, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13VERTEX_SHADERSSvgZTo', symObjAddr: 0x2D4, symBinAddr: 0x104E8, symSize: 0x2C }
-  - { offsetInCU: 0x6D0, offset: 0x80354, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7surfaceSo9IOSurfaceCSgvgTo', symObjAddr: 0x300, symBinAddr: 0x10514, symSize: 0x10 }
-  - { offsetInCU: 0x6F0, offset: 0x80374, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7surfaceSo9IOSurfaceCSgvgTo', symObjAddr: 0x300, symBinAddr: 0x10514, symSize: 0x10 }
-  - { offsetInCU: 0x728, offset: 0x803AC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7surfaceSo9IOSurfaceCSgvsTo', symObjAddr: 0x310, symBinAddr: 0x10524, symSize: 0x34 }
-  - { offsetInCU: 0x781, offset: 0x80405, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8pixelBufs9UnmanagedVySo11CVBufferRefaGSgvgTo', symObjAddr: 0x418, symBinAddr: 0x1062C, symSize: 0x10 }
-  - { offsetInCU: 0x7A1, offset: 0x80425, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8pixelBufs9UnmanagedVySo11CVBufferRefaGSgvgTo', symObjAddr: 0x418, symBinAddr: 0x1062C, symSize: 0x10 }
-  - { offsetInCU: 0x7D7, offset: 0x8045B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8pixelBufs9UnmanagedVySo11CVBufferRefaGSgvsTo', symObjAddr: 0x428, symBinAddr: 0x1063C, symSize: 0x10 }
-  - { offsetInCU: 0x7F7, offset: 0x8047B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8pixelBufs9UnmanagedVySo11CVBufferRefaGSgvsTo', symObjAddr: 0x428, symBinAddr: 0x1063C, symSize: 0x10 }
-  - { offsetInCU: 0x846, offset: 0x804CA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCACycfcTo', symObjAddr: 0x5BC, symBinAddr: 0x10790, symSize: 0x20 }
-  - { offsetInCU: 0x878, offset: 0x804FC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7destroyyyFTo', symObjAddr: 0x720, symBinAddr: 0x108F4, symSize: 0x28 }
-  - { offsetInCU: 0x8D0, offset: 0x80554, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10texImage2Dyys5Int32V_A4fA9NSCCanvasCAHSbtFTo', symObjAddr: 0x75C, symBinAddr: 0x10930, symSize: 0x88 }
-  - { offsetInCU: 0x934, offset: 0x805B8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9drawFrame6buffer5width6height14internalFormat6format10flipYWebGLySo11CVBufferRefa_S2is5Int32VANSbtFTo', symObjAddr: 0x7E4, symBinAddr: 0x109B8, symSize: 0x7C }
-  - { offsetInCU: 0x9D6, offset: 0x8065A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13createSurfaceyyFTo', symObjAddr: 0xC0C, symBinAddr: 0x10DE0, symSize: 0x28 }
-  - { offsetInCU: 0xAC0, offset: 0x80744, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCMa', symObjAddr: 0x59C, symBinAddr: 0x10770, symSize: 0x20 }
-  - { offsetInCU: 0xB34, offset: 0x807B8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCfETo', symObjAddr: 0xC64, symBinAddr: 0x10E38, symSize: 0x58 }
-  - { offsetInCU: 0x123B, offset: 0x80EBF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCACycfC', symObjAddr: 0x438, symBinAddr: 0x1064C, symSize: 0x20 }
-  - { offsetInCU: 0x1255, offset: 0x80ED9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCACycfc', symObjAddr: 0x458, symBinAddr: 0x1066C, symSize: 0x104 }
-  - { offsetInCU: 0x1287, offset: 0x80F0B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7destroyyyF', symObjAddr: 0x5DC, symBinAddr: 0x107B0, symSize: 0x144 }
-  - { offsetInCU: 0x1442, offset: 0x810C6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10texImage2Dyys5Int32V_A4fA9NSCCanvasCAHSbtF', symObjAddr: 0x748, symBinAddr: 0x1091C, symSize: 0x14 }
-  - { offsetInCU: 0x14F3, offset: 0x81177, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13createSurfaceyyF', symObjAddr: 0x860, symBinAddr: 0x10A34, symSize: 0x3AC }
-  - { offsetInCU: 0x1863, offset: 0x814E7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCfD', symObjAddr: 0xC34, symBinAddr: 0x10E08, symSize: 0x30 }
-  - { offsetInCU: 0x194E, offset: 0x815D2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10texImage2Dyys5Int32V_A4fA9NSCCanvasCAHSbtFTf4ddnndnndn_n', symObjAddr: 0xCBC, symBinAddr: 0x10E90, symSize: 0x65C }
-  - { offsetInCU: 0x214C, offset: 0x81DD0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9drawFrame6buffer5width6height14internalFormat6format10flipYWebGLySo11CVBufferRefa_S2is5Int32VANSbtFTf4nnnnndn_n', symObjAddr: 0x135C, symBinAddr: 0x11530, symSize: 0x6C8 }
-  - { offsetInCU: 0x10C, offset: 0x82790, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC6target6actionAEypSg_10ObjectiveC8SelectorVSgtcfcTo', symObjAddr: 0xED4, symBinAddr: 0x12AA4, symSize: 0x68 }
-  - { offsetInCU: 0x19C, offset: 0x82820, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerCfETo', symObjAddr: 0xF48, symBinAddr: 0x12B18, symSize: 0x10 }
-  - { offsetInCU: 0x1CB, offset: 0x8284F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC6handleyySo19UIGestureRecognizerCFTo', symObjAddr: 0xF58, symBinAddr: 0x12B28, symSize: 0x4 }
-  - { offsetInCU: 0x368, offset: 0x829EC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerCACycfcTo', symObjAddr: 0x16DC, symBinAddr: 0x132AC, symSize: 0x2C }
-  - { offsetInCU: 0x5D4, offset: 0x82C58, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerCfETo', symObjAddr: 0x1744, symBinAddr: 0x13314, symSize: 0x68 }
-  - { offsetInCU: 0x603, offset: 0x82C87, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerCMa', symObjAddr: 0x17AC, symBinAddr: 0x1337C, symSize: 0x20 }
-  - { offsetInCU: 0x617, offset: 0x82C9B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerCMa', symObjAddr: 0x17CC, symBinAddr: 0x1339C, symSize: 0x20 }
-  - { offsetInCU: 0x62B, offset: 0x82CAF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwCP', symObjAddr: 0x17EC, symBinAddr: 0x133BC, symSize: 0x30 }
-  - { offsetInCU: 0x63F, offset: 0x82CC3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwxx', symObjAddr: 0x181C, symBinAddr: 0x133EC, symSize: 0x8 }
-  - { offsetInCU: 0x653, offset: 0x82CD7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwcp', symObjAddr: 0x1824, symBinAddr: 0x133F4, symSize: 0x3C }
-  - { offsetInCU: 0x667, offset: 0x82CEB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwca', symObjAddr: 0x1860, symBinAddr: 0x13430, symSize: 0x50 }
-  - { offsetInCU: 0x67B, offset: 0x82CFF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwta', symObjAddr: 0x18BC, symBinAddr: 0x13480, symSize: 0x40 }
-  - { offsetInCU: 0x68F, offset: 0x82D13, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwet', symObjAddr: 0x18FC, symBinAddr: 0x134C0, symSize: 0x48 }
-  - { offsetInCU: 0x6A3, offset: 0x82D27, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwst', symObjAddr: 0x1944, symBinAddr: 0x13508, symSize: 0x40 }
-  - { offsetInCU: 0x6B7, offset: 0x82D3B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVMa', symObjAddr: 0x1984, symBinAddr: 0x13548, symSize: 0x10 }
-  - { offsetInCU: 0x6CB, offset: 0x82D4F, size: 0x8, addend: 0x0, symName: '_$sypSgWOc', symObjAddr: 0x1994, symBinAddr: 0x13558, symSize: 0x48 }
-  - { offsetInCU: 0x6DF, offset: 0x82D63, size: 0x8, addend: 0x0, symName: '_$sSo7UITouchCSo8NSObjectCSH10ObjectiveCWl', symObjAddr: 0x1AA0, symBinAddr: 0x135A0, symSize: 0x58 }
-  - { offsetInCU: 0x6F3, offset: 0x82D77, size: 0x8, addend: 0x0, symName: '_$sSh8IteratorV8_VariantOyx__GSHRzlWOe', symObjAddr: 0x1AF8, symBinAddr: 0x135F8, symSize: 0x8 }
-  - { offsetInCU: 0x761, offset: 0x82DE5, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_SgWOe', symObjAddr: 0x1DEC, symBinAddr: 0x138EC, symSize: 0x10 }
-  - { offsetInCU: 0xCBB, offset: 0x8333F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC12touchesBegan_4withyShySo7UITouchCG_So7UIEventCtF', symObjAddr: 0x0, symBinAddr: 0x11BF8, symSize: 0x540 }
-  - { offsetInCU: 0xF57, offset: 0x835DB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC12touchesMoved_4withyShySo7UITouchCG_So7UIEventCtF', symObjAddr: 0x54C, symBinAddr: 0x12144, symSize: 0xE0 }
-  - { offsetInCU: 0xFD6, offset: 0x8365A, size: 0x8, addend: 0x0, symName: '_$sSa6remove2atxSi_tF12CanvasNative15NSCTouchHandlerC7PointerV_Tg5', symObjAddr: 0x6F0, symBinAddr: 0x122D4, symSize: 0x9C }
-  - { offsetInCU: 0x1069, offset: 0x836ED, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC6target6actionAEypSg_10ObjectiveC8SelectorVSgtcfc', symObjAddr: 0xDCC, symBinAddr: 0x1299C, symSize: 0x108 }
-  - { offsetInCU: 0x11B3, offset: 0x83837, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC6onMove33_044DDF836BDB3B89B481C6F58BB6EF6BLLyySo19UIGestureRecognizerC_ShySo7UITouchCGSgtF', symObjAddr: 0x12D0, symBinAddr: 0x12EA0, symSize: 0x40C }
-  - { offsetInCU: 0x18C9, offset: 0x83F4D, size: 0x8, addend: 0x0, symName: '_$ss12_ArrayBufferV20_consumeAndCreateNewAByxGyF12CanvasNative15NSCTouchHandlerC7PointerV_Tg5', symObjAddr: 0x1B00, symBinAddr: 0x13600, symSize: 0x14 }
-  - { offsetInCU: 0x1968, offset: 0x83FEC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC6canvasAcA9NSCCanvasC_tcfcTf4gn_n', symObjAddr: 0x1B14, symBinAddr: 0x13614, symSize: 0x1E4 }
-  - { offsetInCU: 0x27, offset: 0x841C9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC14FAILED_TO_LOADSSvgZTo', symObjAddr: 0x0, symBinAddr: 0x138FC, symSize: 0x2C }
-  - { offsetInCU: 0x4B, offset: 0x841ED, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queueSo012OS_dispatch_E0CvpZ', symObjAddr: 0x2D8, symBinAddr: 0x10D3D08, symSize: 0x0 }
-  - { offsetInCU: 0x65, offset: 0x84207, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC14FAILED_TO_LOADSSvgZTo', symObjAddr: 0x0, symBinAddr: 0x138FC, symSize: 0x2C }
-  - { offsetInCU: 0x98, offset: 0x8423A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queueSo012OS_dispatch_E0CvgZTo', symObjAddr: 0x178, symBinAddr: 0x13A74, symSize: 0x40 }
-  - { offsetInCU: 0x104, offset: 0x842A6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCACycfcTo', symObjAddr: 0x228, symBinAddr: 0x13B24, symSize: 0x3C }
-  - { offsetInCU: 0x156, offset: 0x842F8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queue_WZ', symObjAddr: 0x2C, symBinAddr: 0x13928, symSize: 0x10C }
-  - { offsetInCU: 0x181, offset: 0x84323, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCMa', symObjAddr: 0x208, symBinAddr: 0x13B04, symSize: 0x20 }
-  - { offsetInCU: 0x195, offset: 0x84337, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCfETo', symObjAddr: 0x294, symBinAddr: 0x13B90, symSize: 0x4 }
-  - { offsetInCU: 0x1C0, offset: 0x84362, size: 0x8, addend: 0x0, symName: '_$sSo17OS_dispatch_queueCMa', symObjAddr: 0x298, symBinAddr: 0x13B94, symSize: 0x3C }
-  - { offsetInCU: 0x348, offset: 0x844EA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queueSo012OS_dispatch_E0CvgZ', symObjAddr: 0x138, symBinAddr: 0x13A34, symSize: 0x40 }
-  - { offsetInCU: 0x388, offset: 0x8452A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCACycfC', symObjAddr: 0x1B8, symBinAddr: 0x13AB4, symSize: 0x20 }
-  - { offsetInCU: 0x39C, offset: 0x8453E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCACycfc', symObjAddr: 0x1D8, symBinAddr: 0x13AD4, symSize: 0x30 }
-  - { offsetInCU: 0x3D8, offset: 0x8457A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCfD', symObjAddr: 0x264, symBinAddr: 0x13B60, symSize: 0x30 }
-  - { offsetInCU: 0x2B, offset: 0x845C8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC18createTextureCacheSo017CVOpenGLESTextureF3RefaSgyFZ', symObjAddr: 0x0, symBinAddr: 0x13BD0, symSize: 0xA4 }
-  - { offsetInCU: 0x66, offset: 0x84603, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC18createTextureCacheSo017CVOpenGLESTextureF3RefaSgyFZTo', symObjAddr: 0xA4, symBinAddr: 0x13C74, symSize: 0xA4 }
-  - { offsetInCU: 0xF9, offset: 0x84696, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11createImageySo11CVBufferRefaSgSo022CVOpenGLESTextureCacheG0a_AFSo012CFDictionaryG0aSgs6UInt32Vs5Int32VA2p2NSitFZTo', symObjAddr: 0x1D8, symBinAddr: 0x13DA8, symSize: 0x110 }
-  - { offsetInCU: 0x1A2, offset: 0x8473F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11setupRenderAA9NSCRenderCyFZTo', symObjAddr: 0x30C, symBinAddr: 0x13EDC, symSize: 0x28 }
-  - { offsetInCU: 0x222, offset: 0x847BF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC9drawFrameyySo8AVPlayerC_So0F15ItemVideoOutputCSo6CGSizeVAA9NSCRenderCs5Int32VANSbtFZTo', symObjAddr: 0x338, symBinAddr: 0x13F08, symSize: 0xA0 }
-  - { offsetInCU: 0x29B, offset: 0x84838, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11writeToFileyySo6NSDataC_SStKFZTo', symObjAddr: 0x4D0, symBinAddr: 0x140A0, symSize: 0x15C }
-  - { offsetInCU: 0x330, offset: 0x848CD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCACycfcTo', symObjAddr: 0x67C, symBinAddr: 0x1424C, symSize: 0x3C }
-  - { offsetInCU: 0x381, offset: 0x8491E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC9drawFrameyySo8AVPlayerC_So0F15ItemVideoOutputCSo6CGSizeVAA9NSCRenderCs5Int32VANSbtFZTf4nnnnnndd_n', symObjAddr: 0x6E8, symBinAddr: 0x142B8, symSize: 0x160 }
-  - { offsetInCU: 0x4DF, offset: 0x84A7C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC7getFile33_F00B23A4165DD6ABFCD23C8811C7DF43LLyS2SKFZTf4nd_g', symObjAddr: 0x848, symBinAddr: 0x14418, symSize: 0x2E4 }
-  - { offsetInCU: 0x5AE, offset: 0x84B4B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCMa', symObjAddr: 0xB2C, symBinAddr: 0x146FC, symSize: 0x20 }
-  - { offsetInCU: 0x5C2, offset: 0x84B5F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOAEs5ErrorAAWl', symObjAddr: 0xB4C, symBinAddr: 0x1471C, symSize: 0x44 }
-  - { offsetInCU: 0x5D6, offset: 0x84B73, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwCP', symObjAddr: 0xB90, symBinAddr: 0x14760, symSize: 0x2C }
-  - { offsetInCU: 0x5EA, offset: 0x84B87, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwxx', symObjAddr: 0xBBC, symBinAddr: 0x1478C, symSize: 0x8 }
-  - { offsetInCU: 0x5FE, offset: 0x84B9B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwca', symObjAddr: 0xBC4, symBinAddr: 0x14794, symSize: 0x40 }
-  - { offsetInCU: 0x612, offset: 0x84BAF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwta', symObjAddr: 0xC10, symBinAddr: 0x147D4, symSize: 0x30 }
-  - { offsetInCU: 0x626, offset: 0x84BC3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwet', symObjAddr: 0xC40, symBinAddr: 0x14804, symSize: 0x48 }
-  - { offsetInCU: 0x63A, offset: 0x84BD7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwst', symObjAddr: 0xC88, symBinAddr: 0x1484C, symSize: 0x3C }
-  - { offsetInCU: 0x64E, offset: 0x84BEB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwug', symObjAddr: 0xCC4, symBinAddr: 0x14888, symSize: 0x8 }
-  - { offsetInCU: 0x662, offset: 0x84BFF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwup', symObjAddr: 0xCCC, symBinAddr: 0x14890, symSize: 0x4 }
-  - { offsetInCU: 0x676, offset: 0x84C13, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwui', symObjAddr: 0xCD0, symBinAddr: 0x14894, symSize: 0x4 }
-  - { offsetInCU: 0x68A, offset: 0x84C27, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOMa', symObjAddr: 0xCD4, symBinAddr: 0x14898, symSize: 0x10 }
-  - { offsetInCU: 0x712, offset: 0x84CAF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP7_domainSSvgTW', symObjAddr: 0x3D8, symBinAddr: 0x13FA8, symSize: 0x4 }
-  - { offsetInCU: 0x72E, offset: 0x84CCB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP5_codeSivgTW', symObjAddr: 0x3DC, symBinAddr: 0x13FAC, symSize: 0x4 }
-  - { offsetInCU: 0x74A, offset: 0x84CE7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP9_userInfoyXlSgvgTW', symObjAddr: 0x3E0, symBinAddr: 0x13FB0, symSize: 0x4 }
-  - { offsetInCU: 0x766, offset: 0x84D03, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP19_getEmbeddedNSErroryXlSgyFTW', symObjAddr: 0x3E4, symBinAddr: 0x13FB4, symSize: 0x4 }
-  - { offsetInCU: 0xA14, offset: 0x84FB1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC18createTextureCacheSo017CVOpenGLESTextureF3RefaSgyFZ', symObjAddr: 0x0, symBinAddr: 0x13BD0, symSize: 0xA4 }
-  - { offsetInCU: 0xAAA, offset: 0x85047, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11createImageySo11CVBufferRefaSgSo022CVOpenGLESTextureCacheG0a_AFSo012CFDictionaryG0aSgs6UInt32Vs5Int32VA2p2NSitFZ', symObjAddr: 0x148, symBinAddr: 0x13D18, symSize: 0x90 }
-  - { offsetInCU: 0xC31, offset: 0x851CE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11setupRenderAA9NSCRenderCyFZ', symObjAddr: 0x2E8, symBinAddr: 0x13EB8, symSize: 0x24 }
-  - { offsetInCU: 0xC7B, offset: 0x85218, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC9drawFrameyySo8AVPlayerC_So0F15ItemVideoOutputCSo6CGSizeVAA9NSCRenderCs5Int32VANSbtFZ', symObjAddr: 0x334, symBinAddr: 0x13F04, symSize: 0x4 }
-  - { offsetInCU: 0xC9D, offset: 0x8523A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11writeToFileyySo6NSDataC_SStKFZ', symObjAddr: 0x3E8, symBinAddr: 0x13FB8, symSize: 0xE8 }
-  - { offsetInCU: 0xD4D, offset: 0x852EA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCACycfC', symObjAddr: 0x62C, symBinAddr: 0x141FC, symSize: 0x20 }
-  - { offsetInCU: 0xD61, offset: 0x852FE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCACycfc', symObjAddr: 0x64C, symBinAddr: 0x1421C, symSize: 0x30 }
-  - { offsetInCU: 0xD97, offset: 0x85334, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCfD', symObjAddr: 0x6B8, symBinAddr: 0x14288, symSize: 0x30 }
-  - { offsetInCU: 0x27, offset: 0x8544D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x0, symBinAddr: 0x148AC, symSize: 0x4 }
-  - { offsetInCU: 0x71, offset: 0x85497, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZTo', symObjAddr: 0x4, symBinAddr: 0x148B0, symSize: 0x70 }
-  - { offsetInCU: 0xF6, offset: 0x8551C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS2ftFZTo', symObjAddr: 0x78, symBinAddr: 0x14924, symSize: 0x50 }
-  - { offsetInCU: 0x191, offset: 0x855B7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS4ftFZTo', symObjAddr: 0xCC, symBinAddr: 0x14978, symSize: 0x68 }
-  - { offsetInCU: 0x254, offset: 0x8567A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS8ftFZTo', symObjAddr: 0x138, symBinAddr: 0x149E4, symSize: 0x98 }
-  - { offsetInCU: 0x323, offset: 0x85749, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCACycfcTo', symObjAddr: 0x220, symBinAddr: 0x14ACC, symSize: 0x3C }
-  - { offsetInCU: 0x375, offset: 0x8579B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCMa', symObjAddr: 0x28C, symBinAddr: 0x14B38, symSize: 0x20 }
-  - { offsetInCU: 0x4E5, offset: 0x8590B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x0, symBinAddr: 0x148AC, symSize: 0x4 }
-  - { offsetInCU: 0x51D, offset: 0x85943, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x0, symBinAddr: 0x148AC, symSize: 0x4 }
-  - { offsetInCU: 0x588, offset: 0x859AE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS2ftFZ', symObjAddr: 0x74, symBinAddr: 0x14920, symSize: 0x4 }
-  - { offsetInCU: 0x5C8, offset: 0x859EE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS2ftFZ', symObjAddr: 0x74, symBinAddr: 0x14920, symSize: 0x4 }
-  - { offsetInCU: 0x62A, offset: 0x85A50, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS4ftFZ', symObjAddr: 0xC8, symBinAddr: 0x14974, symSize: 0x4 }
-  - { offsetInCU: 0x67C, offset: 0x85AA2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS4ftFZ', symObjAddr: 0xC8, symBinAddr: 0x14974, symSize: 0x4 }
-  - { offsetInCU: 0x6F1, offset: 0x85B17, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS8ftFZ', symObjAddr: 0x134, symBinAddr: 0x149E0, symSize: 0x4 }
-  - { offsetInCU: 0x767, offset: 0x85B8D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS8ftFZ', symObjAddr: 0x134, symBinAddr: 0x149E0, symSize: 0x4 }
-  - { offsetInCU: 0x805, offset: 0x85C2B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCACycfC', symObjAddr: 0x1D0, symBinAddr: 0x14A7C, symSize: 0x20 }
-  - { offsetInCU: 0x819, offset: 0x85C3F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCACycfc', symObjAddr: 0x1F0, symBinAddr: 0x14A9C, symSize: 0x30 }
-  - { offsetInCU: 0x84F, offset: 0x85C75, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCfD', symObjAddr: 0x25C, symBinAddr: 0x14B08, symSize: 0x30 }
-  - { offsetInCU: 0x27, offset: 0x85CBF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC10texImage2Dyys5Int64V_s5Int32VA4HSpys5UInt8VGSuSo6CGSizeVSbtFZ', symObjAddr: 0x0, symBinAddr: 0x14B58, symSize: 0x14 }
-  - { offsetInCU: 0xA9, offset: 0x85D41, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC10texImage2Dyys5Int64V_s5Int32VA4HSpys5UInt8VGSuSo6CGSizeVSbtFZTo', symObjAddr: 0x14, symBinAddr: 0x14B6C, symSize: 0x38 }
-  - { offsetInCU: 0x1A2, offset: 0x85E3A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC13texSubImage2Dyys5Int64V_s5Int32VA5HSpys5UInt8VGSuSo6CGSizeVSbtFZTo', symObjAddr: 0x68, symBinAddr: 0x14BC0, symSize: 0x40 }
-  - { offsetInCU: 0x284, offset: 0x85F1C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCACycfcTo', symObjAddr: 0x118, symBinAddr: 0x14C70, symSize: 0x3C }
-  - { offsetInCU: 0x2D6, offset: 0x85F6E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCMa', symObjAddr: 0xF8, symBinAddr: 0x14C50, symSize: 0x20 }
-  - { offsetInCU: 0x480, offset: 0x86118, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC10texImage2Dyys5Int64V_s5Int32VA4HSpys5UInt8VGSuSo6CGSizeVSbtFZ', symObjAddr: 0x0, symBinAddr: 0x14B58, symSize: 0x14 }
-  - { offsetInCU: 0x5C4, offset: 0x8625C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC13texSubImage2Dyys5Int64V_s5Int32VA5HSpys5UInt8VGSuSo6CGSizeVSbtFZ', symObjAddr: 0x4C, symBinAddr: 0x14BA4, symSize: 0x1C }
-  - { offsetInCU: 0x6FA, offset: 0x86392, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCACycfC', symObjAddr: 0xA8, symBinAddr: 0x14C00, symSize: 0x20 }
-  - { offsetInCU: 0x70E, offset: 0x863A6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCACycfc', symObjAddr: 0xC8, symBinAddr: 0x14C20, symSize: 0x30 }
-  - { offsetInCU: 0x744, offset: 0x863DC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCfD', symObjAddr: 0x154, symBinAddr: 0x14CAC, symSize: 0x30 }
-  - { offsetInCU: 0x61, offset: 0x86460, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7isDirtySbvgTo', symObjAddr: 0x4, symBinAddr: 0x14CE0, symSize: 0x10 }
-  - { offsetInCU: 0x81, offset: 0x86480, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7isDirtySbvgTo', symObjAddr: 0x4, symBinAddr: 0x14CE0, symSize: 0x10 }
-  - { offsetInCU: 0xB7, offset: 0x864B6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7isDirtySbvsTo', symObjAddr: 0x14, symBinAddr: 0x14CF0, symSize: 0x10 }
-  - { offsetInCU: 0xD7, offset: 0x864D6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7isDirtySbvsTo', symObjAddr: 0x14, symBinAddr: 0x14CF0, symSize: 0x10 }
-  - { offsetInCU: 0x110, offset: 0x8650F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC6canvasAA9NSCCanvasCSgvgTo', symObjAddr: 0x24, symBinAddr: 0x14D00, symSize: 0x48 }
-  - { offsetInCU: 0x168, offset: 0x86567, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC6canvasAA9NSCCanvasCSgvsTo', symObjAddr: 0xB4, symBinAddr: 0x14D90, symSize: 0x50 }
-  - { offsetInCU: 0x1C3, offset: 0x865C2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC3fbos6UInt32VvgTo', symObjAddr: 0x104, symBinAddr: 0x14DE0, symSize: 0x10 }
-  - { offsetInCU: 0x1E3, offset: 0x865E2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC3fbos6UInt32VvgTo', symObjAddr: 0x104, symBinAddr: 0x14DE0, symSize: 0x10 }
-  - { offsetInCU: 0x219, offset: 0x86618, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC3fbos6UInt32VvsTo', symObjAddr: 0x114, symBinAddr: 0x14DF0, symSize: 0x10 }
-  - { offsetInCU: 0x239, offset: 0x86638, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC3fbos6UInt32VvsTo', symObjAddr: 0x114, symBinAddr: 0x14DF0, symSize: 0x10 }
-  - { offsetInCU: 0x272, offset: 0x86671, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCACycfcTo', symObjAddr: 0x1B0, symBinAddr: 0x14E8C, symSize: 0x78 }
-  - { offsetInCU: 0x2C8, offset: 0x866C7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frameACSo6CGRectV_tcfcTo', symObjAddr: 0x2D4, symBinAddr: 0x14FB0, symSize: 0xB0 }
-  - { offsetInCU: 0x32A, offset: 0x86729, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5coderACSgSo7NSCoderC_tcfcTo', symObjAddr: 0x43C, symBinAddr: 0x15118, symSize: 0x28 }
-  - { offsetInCU: 0x35C, offset: 0x8675B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC12bindDrawableyyFTo', symObjAddr: 0x4E0, symBinAddr: 0x15140, symSize: 0xA0 }
-  - { offsetInCU: 0x3DD, offset: 0x867DC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC14deleteDrawableyyFTo', symObjAddr: 0x5BC, symBinAddr: 0x151E0, symSize: 0x60 }
-  - { offsetInCU: 0x44D, offset: 0x8684C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7glkView_6drawInySo0C0C_So6CGRectVtFTo', symObjAddr: 0x620, symBinAddr: 0x15244, symSize: 0x4C }
-  - { offsetInCU: 0x4BF, offset: 0x868BE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frame7contextACSo6CGRectV_So11EAGLContextCtcfcTo', symObjAddr: 0x70C, symBinAddr: 0x15330, symSize: 0x34 }
-  - { offsetInCU: 0x533, offset: 0x86932, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCMa', symObjAddr: 0x190, symBinAddr: 0x14E6C, symSize: 0x20 }
-  - { offsetInCU: 0x55D, offset: 0x8695C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCfETo', symObjAddr: 0x74C, symBinAddr: 0x15370, symSize: 0x10 }
-  - { offsetInCU: 0x65B, offset: 0x86A5A, size: 0x8, addend: 0x0, symName: '_$sSo7GLKViewC12CanvasNativeE16snapshotWithDatayy10Foundation0F0VFTo', symObjAddr: 0xA08, symBinAddr: 0x1562C, symSize: 0x74 }
-  - { offsetInCU: 0x699, offset: 0x86A98, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC7isDirtySbvgTo', symObjAddr: 0xA7C, symBinAddr: 0x156A0, symSize: 0x10 }
-  - { offsetInCU: 0x6B9, offset: 0x86AB8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC7isDirtySbvgTo', symObjAddr: 0xA7C, symBinAddr: 0x156A0, symSize: 0x10 }
-  - { offsetInCU: 0x6EF, offset: 0x86AEE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC7isDirtySbvsTo', symObjAddr: 0xA8C, symBinAddr: 0x156B0, symSize: 0x10 }
-  - { offsetInCU: 0x70F, offset: 0x86B0E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC7isDirtySbvsTo', symObjAddr: 0xA8C, symBinAddr: 0x156B0, symSize: 0x10 }
-  - { offsetInCU: 0x748, offset: 0x86B47, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC8rendererAA9NSCCanvasCSgvgTo', symObjAddr: 0xA9C, symBinAddr: 0x156C0, symSize: 0x20 }
-  - { offsetInCU: 0x7A0, offset: 0x86B9F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC8rendererAA9NSCCanvasCSgvsTo', symObjAddr: 0xABC, symBinAddr: 0x156E0, symSize: 0x14 }
-  - { offsetInCU: 0x7FB, offset: 0x86BFA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvgTo', symObjAddr: 0xAD0, symBinAddr: 0x156F4, symSize: 0x44 }
-  - { offsetInCU: 0x853, offset: 0x86C52, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvsTo', symObjAddr: 0xB58, symBinAddr: 0x1577C, symSize: 0x48 }
-  - { offsetInCU: 0x8E8, offset: 0x86CE7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCACycfcTo', symObjAddr: 0xCBC, symBinAddr: 0x158E0, symSize: 0x78 }
-  - { offsetInCU: 0x93E, offset: 0x86D3D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5frameACSo6CGRectV_tcfcTo', symObjAddr: 0xE34, symBinAddr: 0x15A58, symSize: 0xB0 }
-  - { offsetInCU: 0x9A0, offset: 0x86D9F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5coderACSgSo7NSCoderC_tcfcTo', symObjAddr: 0xF90, symBinAddr: 0x15BB4, symSize: 0x28 }
-  - { offsetInCU: 0x9D2, offset: 0x86DD1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC11deviceScaleSfyFTo', symObjAddr: 0xFB8, symBinAddr: 0x15BDC, symSize: 0xB8 }
-  - { offsetInCU: 0xA53, offset: 0x86E52, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC4drawyySo6CGRectVFTo', symObjAddr: 0x1074, symBinAddr: 0x15C94, symSize: 0x28 }
-  - { offsetInCU: 0xAB1, offset: 0x86EB0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCfETo', symObjAddr: 0x10D8, symBinAddr: 0x15CF8, symSize: 0x10 }
-  - { offsetInCU: 0xC63, offset: 0x87062, size: 0x8, addend: 0x0, symName: '_$ss22_ContiguousArrayBufferV19_uninitializedCount15minimumCapacityAByxGSi_SitcfC12CanvasNative15NSCTouchHandlerC7PointerV_Tgm5', symObjAddr: 0x130C, symBinAddr: 0x15E78, symSize: 0x80 }
-  - { offsetInCU: 0xCE6, offset: 0x870E5, size: 0x8, addend: 0x0, symName: '_$ss22_ContiguousArrayBufferV19_uninitializedCount15minimumCapacityAByxGSi_SitcfCs5UInt8V_Tgm5', symObjAddr: 0x140C, symBinAddr: 0x15EF8, symSize: 0x6C }
-  - { offsetInCU: 0xD6A, offset: 0x87169, size: 0x8, addend: 0x0, symName: '_$s10Foundation4DataV15_RepresentationOWOy', symObjAddr: 0x1630, symBinAddr: 0x1611C, symSize: 0x44 }
-  - { offsetInCU: 0xD7E, offset: 0x8717D, size: 0x8, addend: 0x0, symName: '_$s10Foundation4DataV15_RepresentationOWOe', symObjAddr: 0x1674, symBinAddr: 0x16160, symSize: 0x44 }
-  - { offsetInCU: 0xD92, offset: 0x87191, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCMa', symObjAddr: 0x16B8, symBinAddr: 0x161A4, symSize: 0x20 }
-  - { offsetInCU: 0xE6C, offset: 0x8726B, size: 0x8, addend: 0x0, symName: '_$sSaySayxGqd__c7ElementQyd__RszSTRd__lufCs5UInt8V_10Foundation4DataVTgm5Tf4g_n', symObjAddr: 0x14FC, symBinAddr: 0x15FE8, symSize: 0x124 }
-  - { offsetInCU: 0x112B, offset: 0x8752A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC6canvasAA9NSCCanvasCSgvg', symObjAddr: 0x6C, symBinAddr: 0x14D48, symSize: 0x48 }
-  - { offsetInCU: 0x11A8, offset: 0x875A7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCACycfc', symObjAddr: 0x124, symBinAddr: 0x14E00, symSize: 0x6C }
-  - { offsetInCU: 0x11EF, offset: 0x875EE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frameACSo6CGRectV_tcfc', symObjAddr: 0x228, symBinAddr: 0x14F04, symSize: 0xAC }
-  - { offsetInCU: 0x1253, offset: 0x87652, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5coderACSgSo7NSCoderC_tcfc', symObjAddr: 0x384, symBinAddr: 0x15060, symSize: 0xB8 }
-  - { offsetInCU: 0x12DE, offset: 0x876DD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7glkView_6drawInySo0C0C_So6CGRectVtF', symObjAddr: 0x61C, symBinAddr: 0x15240, symSize: 0x4 }
-  - { offsetInCU: 0x12FF, offset: 0x876FE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frame7contextACSo6CGRectV_So11EAGLContextCtcfC', symObjAddr: 0x66C, symBinAddr: 0x15290, symSize: 0x74 }
-  - { offsetInCU: 0x1313, offset: 0x87712, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frame7contextACSo6CGRectV_So11EAGLContextCtcfc', symObjAddr: 0x6E0, symBinAddr: 0x15304, symSize: 0x2C }
-  - { offsetInCU: 0x142C, offset: 0x8782B, size: 0x8, addend: 0x0, symName: '_$sSo7GLKViewC12CanvasNativeE16snapshotWithDatayy10Foundation0F0VF', symObjAddr: 0x75C, symBinAddr: 0x15380, symSize: 0x2AC }
-  - { offsetInCU: 0x17D6, offset: 0x87BD5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvg', symObjAddr: 0xB14, symBinAddr: 0x15738, symSize: 0x44 }
-  - { offsetInCU: 0x1815, offset: 0x87C14, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvs', symObjAddr: 0xBA0, symBinAddr: 0x157C4, symSize: 0x48 }
-  - { offsetInCU: 0x183A, offset: 0x87C39, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvM', symObjAddr: 0xBE8, symBinAddr: 0x1580C, symSize: 0x44 }
-  - { offsetInCU: 0x185F, offset: 0x87C5E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvM.resume.0', symObjAddr: 0xC2C, symBinAddr: 0x15850, symSize: 0x4 }
-  - { offsetInCU: 0x1886, offset: 0x87C85, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCACycfC', symObjAddr: 0xC30, symBinAddr: 0x15854, symSize: 0x20 }
-  - { offsetInCU: 0x189A, offset: 0x87C99, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCACycfc', symObjAddr: 0xC50, symBinAddr: 0x15874, symSize: 0x6C }
-  - { offsetInCU: 0x18E1, offset: 0x87CE0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5frameACSo6CGRectV_tcfc', symObjAddr: 0xD88, symBinAddr: 0x159AC, symSize: 0xAC }
-  - { offsetInCU: 0x1940, offset: 0x87D3F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5coderACSgSo7NSCoderC_tcfc', symObjAddr: 0xEE4, symBinAddr: 0x15B08, symSize: 0xAC }
-  - { offsetInCU: 0x19DE, offset: 0x87DDD, size: 0x8, addend: 0x0, symName: '_$ss12_ArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtF12CanvasNative15NSCTouchHandlerC7PointerV_Tg5', symObjAddr: 0x10E8, symBinAddr: 0x15D08, symSize: 0xBC }
-  - { offsetInCU: 0x1AC0, offset: 0x87EBF, size: 0x8, addend: 0x0, symName: '_$ss12_ArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtFs5UInt8V_Tg5', symObjAddr: 0x1258, symBinAddr: 0x15DC4, symSize: 0xB4 }
-  - { offsetInCU: 0x1BCC, offset: 0x87FCB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7glkView_6drawInySo0C0C_So6CGRectVtFTf4ddn_n', symObjAddr: 0x1478, symBinAddr: 0x15F64, symSize: 0x84 }
-  - { offsetInCU: 0x1CC5, offset: 0x880C4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC4drawyySo6CGRectVFTf4dn_n', symObjAddr: 0x16D8, symBinAddr: 0x161C4, symSize: 0x360 }
-  - { offsetInCU: 0x4F, offset: 0x88502, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC5queue33_7ED578B0ED4B2B6F6887A622A7B49AA3LLSo012OS_dispatch_E0CvpZ', symObjAddr: 0x980, symBinAddr: 0x10D3E50, symSize: 0x0 }
-  - { offsetInCU: 0x5D, offset: 0x88510, size: 0x8, addend: 0x0, symName: '_$sIegh_IeyBh_TR', symObjAddr: 0x0, symBinAddr: 0x16710, symSize: 0x2C }
-  - { offsetInCU: 0x75, offset: 0x88528, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC5queue33_7ED578B0ED4B2B6F6887A622A7B49AA3LL_WZ', symObjAddr: 0x2C, symBinAddr: 0x1673C, symSize: 0x10C }
-  - { offsetInCU: 0xBC, offset: 0x8856F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF4SyncySbs5Int64V_So7UIImageCtFZTo', symObjAddr: 0x13C, symBinAddr: 0x1684C, symSize: 0x44 }
-  - { offsetInCU: 0x132, offset: 0x885E5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZTo', symObjAddr: 0x3E4, symBinAddr: 0x16AF4, symSize: 0x80 }
-  - { offsetInCU: 0x191, offset: 0x88644, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCACycfcTo', symObjAddr: 0x4B4, symBinAddr: 0x16BC4, symSize: 0x3C }
-  - { offsetInCU: 0x1E2, offset: 0x88695, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZTf4nnnd_n', symObjAddr: 0x524, symBinAddr: 0x16C34, symSize: 0x214 }
-  - { offsetInCU: 0x261, offset: 0x88714, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCfETo', symObjAddr: 0x520, symBinAddr: 0x16C30, symSize: 0x4 }
-  - { offsetInCU: 0x29D, offset: 0x88750, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCMa', symObjAddr: 0x738, symBinAddr: 0x16E48, symSize: 0x20 }
-  - { offsetInCU: 0x2BC, offset: 0x8876F, size: 0x8, addend: 0x0, symName: '_$s10ObjectiveC8ObjCBoolVIeyBy_SbIegy_TRTA', symObjAddr: 0x77C, symBinAddr: 0x16E8C, symSize: 0x14 }
-  - { offsetInCU: 0x2E5, offset: 0x88798, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_TA', symObjAddr: 0x7BC, symBinAddr: 0x16ECC, symSize: 0xC }
-  - { offsetInCU: 0x2F9, offset: 0x887AC, size: 0x8, addend: 0x0, symName: _block_copy_helper, symObjAddr: 0x7C8, symBinAddr: 0x16ED8, symSize: 0x10 }
-  - { offsetInCU: 0x30D, offset: 0x887C0, size: 0x8, addend: 0x0, symName: _block_destroy_helper, symObjAddr: 0x7D8, symBinAddr: 0x16EE8, symSize: 0x8 }
-  - { offsetInCU: 0x321, offset: 0x887D4, size: 0x8, addend: 0x0, symName: '_$sSay8Dispatch0A13WorkItemFlagsVGMa', symObjAddr: 0x860, symBinAddr: 0x16F30, symSize: 0x54 }
-  - { offsetInCU: 0x335, offset: 0x887E8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_yyScMYccfU0_TA', symObjAddr: 0x8F0, symBinAddr: 0x16F84, symSize: 0x24 }
-  - { offsetInCU: 0x369, offset: 0x8881C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_yyScMYccfU_TA', symObjAddr: 0x938, symBinAddr: 0x16FCC, symSize: 0x24 }
-  - { offsetInCU: 0x4FE, offset: 0x889B1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF4SyncySbs5Int64V_So7UIImageCtFZ', symObjAddr: 0x138, symBinAddr: 0x16848, symSize: 0x4 }
-  - { offsetInCU: 0x52C, offset: 0x889DF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF4SyncySbs5Int64V_So7UIImageCtFZ', symObjAddr: 0x138, symBinAddr: 0x16848, symSize: 0x4 }
-  - { offsetInCU: 0x58B, offset: 0x88A3E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZ', symObjAddr: 0x180, symBinAddr: 0x16890, symSize: 0x4 }
-  - { offsetInCU: 0x59F, offset: 0x88A52, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_', symObjAddr: 0x184, symBinAddr: 0x16894, symSize: 0x260 }
-  - { offsetInCU: 0x678, offset: 0x88B2B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCACycfC', symObjAddr: 0x464, symBinAddr: 0x16B74, symSize: 0x20 }
-  - { offsetInCU: 0x68C, offset: 0x88B3F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCACycfc', symObjAddr: 0x484, symBinAddr: 0x16B94, symSize: 0x30 }
-  - { offsetInCU: 0x6C2, offset: 0x88B75, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCfD', symObjAddr: 0x4F0, symBinAddr: 0x16C00, symSize: 0x30 }
-  - { offsetInCU: 0x27, offset: 0x88C1B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfC', symObjAddr: 0x0, symBinAddr: 0x17004, symSize: 0x20 }
-  - { offsetInCU: 0x77, offset: 0x88C6B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfcTo', symObjAddr: 0x70, symBinAddr: 0x17074, symSize: 0x3C }
-  - { offsetInCU: 0xC9, offset: 0x88CBD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCMa', symObjAddr: 0x50, symBinAddr: 0x17054, symSize: 0x20 }
-  - { offsetInCU: 0x214, offset: 0x88E08, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfC', symObjAddr: 0x0, symBinAddr: 0x17004, symSize: 0x20 }
-  - { offsetInCU: 0x228, offset: 0x88E1C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfc', symObjAddr: 0x20, symBinAddr: 0x17024, symSize: 0x30 }
-  - { offsetInCU: 0x264, offset: 0x88E58, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCfD', symObjAddr: 0xAC, symBinAddr: 0x170B0, symSize: 0x30 }
-  - { offsetInCU: 0x26, offset: 0x88EA1, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_frombytes_vartime, symObjAddr: 0x0, symBinAddr: 0x2B8E40, symSize: 0x265C }
-  - { offsetInCU: 0x40, offset: 0x88EBB, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_k25519Precomp, symObjAddr: 0x9DE0, symBinAddr: 0x9A41C0, symSize: 0x0 }
-  - { offsetInCU: 0x92, offset: 0x88F0D, size: 0x8, addend: 0x0, symName: _d, symObjAddr: 0xFDE0, symBinAddr: 0x9AA1C0, symSize: 0x0 }
-  - { offsetInCU: 0xF6, offset: 0x88F71, size: 0x8, addend: 0x0, symName: _sqrtm1, symObjAddr: 0xFE08, symBinAddr: 0x9AA1E8, symSize: 0x0 }
-  - { offsetInCU: 0x10C, offset: 0x88F87, size: 0x8, addend: 0x0, symName: _d2, symObjAddr: 0x10210, symBinAddr: 0x9AA5F0, symSize: 0x0 }
-  - { offsetInCU: 0x123, offset: 0x88F9E, size: 0x8, addend: 0x0, symName: _Bi, symObjAddr: 0xFE50, symBinAddr: 0x9AA230, symSize: 0x0 }
-  - { offsetInCU: 0x9C2, offset: 0x8983D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_frombytes_vartime, symObjAddr: 0x0, symBinAddr: 0x2B8E40, symSize: 0x265C }
-  - { offsetInCU: 0x45CD, offset: 0x8D448, size: 0x8, addend: 0x0, symName: _fe_frombytes, symObjAddr: 0x265C, symBinAddr: 0x2BB49C, symSize: 0x134 }
-  - { offsetInCU: 0x46F3, offset: 0x8D56E, size: 0x8, addend: 0x0, symName: _fe_mul_impl, symObjAddr: 0x9918, symBinAddr: 0x2C2758, symSize: 0x21C }
-  - { offsetInCU: 0x4922, offset: 0x8D79D, size: 0x8, addend: 0x0, symName: _fe_tobytes, symObjAddr: 0x4FDC, symBinAddr: 0x2BDE1C, symSize: 0x1B8 }
-  - { offsetInCU: 0x530F, offset: 0x8E18A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_scalarmult_base, symObjAddr: 0x2790, symBinAddr: 0x2BB5D0, symSize: 0x5BC }
-  - { offsetInCU: 0x5F72, offset: 0x8EDED, size: 0x8, addend: 0x0, symName: _table_select, symObjAddr: 0x2D4C, symBinAddr: 0x2BBB8C, symSize: 0x7F8 }
-  - { offsetInCU: 0x642A, offset: 0x8F2A5, size: 0x8, addend: 0x0, symName: _ge_madd, symObjAddr: 0x3544, symBinAddr: 0x2BC384, symSize: 0x208 }
-  - { offsetInCU: 0x69F8, offset: 0x8F873, size: 0x8, addend: 0x0, symName: _ge_p2_dbl, symObjAddr: 0x374C, symBinAddr: 0x2BC58C, symSize: 0x7B0 }
-  - { offsetInCU: 0x77D8, offset: 0x90653, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_sc_reduce, symObjAddr: 0x3EFC, symBinAddr: 0x2BCD3C, symSize: 0x634 }
-  - { offsetInCU: 0x8199, offset: 0x91014, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_scalar_mult_generic_masked, symObjAddr: 0x4530, symBinAddr: 0x2BD370, symSize: 0xAAC }
-  - { offsetInCU: 0x956A, offset: 0x923E5, size: 0x8, addend: 0x0, symName: _fe_loose_invert, symObjAddr: 0x5298, symBinAddr: 0x2BE0D8, symSize: 0x23F8 }
-  - { offsetInCU: 0xCABB, offset: 0x95936, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_public_from_private_generic_masked, symObjAddr: 0x5194, symBinAddr: 0x2BDFD4, symSize: 0x104 }
-  - { offsetInCU: 0xCD03, offset: 0x95B7E, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_invert, symObjAddr: 0x7690, symBinAddr: 0x2C04D0, symSize: 0x30 }
-  - { offsetInCU: 0xCDF4, offset: 0x95C6F, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_isnegative, symObjAddr: 0x76C0, symBinAddr: 0x2C0500, symSize: 0x58 }
-  - { offsetInCU: 0xCE69, offset: 0x95CE4, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_mul_ttt, symObjAddr: 0x7718, symBinAddr: 0x2C0558, symSize: 0x4 }
-  - { offsetInCU: 0xCEB1, offset: 0x95D2C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_mul_ttt, symObjAddr: 0x7718, symBinAddr: 0x2C0558, symSize: 0x4 }
-  - { offsetInCU: 0xCEE0, offset: 0x95D5B, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_mul_ttt, symObjAddr: 0x7718, symBinAddr: 0x2C0558, symSize: 0x4 }
-  - { offsetInCU: 0xCF04, offset: 0x95D7F, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_neg, symObjAddr: 0x771C, symBinAddr: 0x2C055C, symSize: 0x8C }
-  - { offsetInCU: 0xD039, offset: 0x95EB4, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_tobytes, symObjAddr: 0x77A8, symBinAddr: 0x2C05E8, symSize: 0x4 }
-  - { offsetInCU: 0xD072, offset: 0x95EED, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_tobytes, symObjAddr: 0x77A8, symBinAddr: 0x2C05E8, symSize: 0x4 }
-  - { offsetInCU: 0xD30B, offset: 0x96186, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_double_scalarmult_vartime, symObjAddr: 0x77AC, symBinAddr: 0x2C05EC, symSize: 0x1598 }
-  - { offsetInCU: 0x10654, offset: 0x994CF, size: 0x8, addend: 0x0, symName: _x25519_ge_add, symObjAddr: 0x9B34, symBinAddr: 0x2C2974, symSize: 0x218 }
-  - { offsetInCU: 0x10C86, offset: 0x99B01, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_sc_mask, symObjAddr: 0x8D44, symBinAddr: 0x2C1B84, symSize: 0x20 }
-  - { offsetInCU: 0x11123, offset: 0x99F9E, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_sc_muladd, symObjAddr: 0x8D64, symBinAddr: 0x2C1BA4, symSize: 0xBB4 }
-  - { offsetInCU: 0x26, offset: 0x9AD81, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_from_montgomery_in_place, symObjAddr: 0x0, symBinAddr: 0x2C2B8C, symSize: 0x1F4 }
-  - { offsetInCU: 0x1D2, offset: 0x9AF2D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_from_montgomery_in_place, symObjAddr: 0x0, symBinAddr: 0x2C2B8C, symSize: 0x1F4 }
-  - { offsetInCU: 0x26, offset: 0x9B1C8, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_neg_inv_mod_r_u64, symObjAddr: 0x0, symBinAddr: 0x2C2D80, symSize: 0x3C }
-  - { offsetInCU: 0x34, offset: 0x9B1D6, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_neg_inv_mod_r_u64, symObjAddr: 0x0, symBinAddr: 0x2C2D80, symSize: 0x3C }
-  - { offsetInCU: 0x26, offset: 0x9B2E6, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_little_endian_bytes_from_scalar, symObjAddr: 0x0, symBinAddr: 0x2C2DBC, symSize: 0x98 }
-  - { offsetInCU: 0x34, offset: 0x9B2F4, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_little_endian_bytes_from_scalar, symObjAddr: 0x0, symBinAddr: 0x2C2DBC, symSize: 0x98 }
-  - { offsetInCU: 0x86, offset: 0x9B457, size: 0x8, addend: 0x0, symName: _Q_N0, symObjAddr: 0x1100, symBinAddr: 0x9AA6A0, symSize: 0x0 }
-  - { offsetInCU: 0xB8, offset: 0x9B489, size: 0x8, addend: 0x0, symName: _Q, symObjAddr: 0x1090, symBinAddr: 0x9AA630, symSize: 0x0 }
-  - { offsetInCU: 0xDA, offset: 0x9B4AB, size: 0x8, addend: 0x0, symName: _N, symObjAddr: 0x10C0, symBinAddr: 0x9AA660, symSize: 0x0 }
-  - { offsetInCU: 0xF0, offset: 0x9B4C1, size: 0x8, addend: 0x0, symName: _N_N0, symObjAddr: 0x10F0, symBinAddr: 0x9AA690, symSize: 0x0 }
-  - { offsetInCU: 0x3B7, offset: 0x9B788, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_elem_mul_mont, symObjAddr: 0x100, symBinAddr: 0x2C2E54, symSize: 0x18 }
-  - { offsetInCU: 0x3FB, offset: 0x9B7CC, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_elem_mul_mont, symObjAddr: 0x100, symBinAddr: 0x2C2E54, symSize: 0x18 }
-  - { offsetInCU: 0x594, offset: 0x9B965, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_scalar_mul_mont, symObjAddr: 0x1F8, symBinAddr: 0x2C2E6C, symSize: 0x18 }
-  - { offsetInCU: 0x63F, offset: 0x9BA10, size: 0x8, addend: 0x0, symName: _nistz384_point_double, symObjAddr: 0x290, symBinAddr: 0x2C2E84, symSize: 0x320 }
-  - { offsetInCU: 0x1199, offset: 0x9C56A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_point_add, symObjAddr: 0x5B0, symBinAddr: 0x2C31A4, symSize: 0xAC }
-  - { offsetInCU: 0x148F, offset: 0x9C860, size: 0x8, addend: 0x0, symName: _nistz384_point_add, symObjAddr: 0x65C, symBinAddr: 0x2C3250, symSize: 0x500 }
-  - { offsetInCU: 0x268C, offset: 0x9DA5D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_point_mul, symObjAddr: 0xB5C, symBinAddr: 0x2C3750, symSize: 0x2C8 }
-  - { offsetInCU: 0x2CDB, offset: 0x9E0AC, size: 0x8, addend: 0x0, symName: _p384_point_select_w5, symObjAddr: 0xE24, symBinAddr: 0x2C3A18, symSize: 0xF4 }
-  - { offsetInCU: 0x2EED, offset: 0x9E2BE, size: 0x8, addend: 0x0, symName: _add_precomputed_w5, symObjAddr: 0xF18, symBinAddr: 0x2C3B0C, symSize: 0x168 }
-  - { offsetInCU: 0x26, offset: 0x9E623, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_zero, symObjAddr: 0x0, symBinAddr: 0x2C3C74, symSize: 0x38 }
-  - { offsetInCU: 0xFA, offset: 0x9E6F7, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_zero, symObjAddr: 0x0, symBinAddr: 0x2C3C74, symSize: 0x38 }
-  - { offsetInCU: 0x12C, offset: 0x9E729, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_zero, symObjAddr: 0x0, symBinAddr: 0x2C3C74, symSize: 0x38 }
-  - { offsetInCU: 0x199, offset: 0x9E796, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_equal, symObjAddr: 0x38, symBinAddr: 0x2C3CAC, symSize: 0x3C }
-  - { offsetInCU: 0x1F3, offset: 0x9E7F0, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_equal, symObjAddr: 0x38, symBinAddr: 0x2C3CAC, symSize: 0x3C }
-  - { offsetInCU: 0x31B, offset: 0x9E918, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_equal_limb, symObjAddr: 0x74, symBinAddr: 0x2C3CE8, symSize: 0x5C }
-  - { offsetInCU: 0x517, offset: 0x9EB14, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_even, symObjAddr: 0xD0, symBinAddr: 0x2C3D44, symSize: 0x1C }
-  - { offsetInCU: 0x636, offset: 0x9EC33, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_less_than, symObjAddr: 0xEC, symBinAddr: 0x2C3D60, symSize: 0x54 }
-  - { offsetInCU: 0x6D9, offset: 0x9ECD6, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_less_than_limb, symObjAddr: 0x140, symBinAddr: 0x2C3DB4, symSize: 0x4C }
-  - { offsetInCU: 0x8A7, offset: 0x9EEA4, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_reduce_once, symObjAddr: 0x18C, symBinAddr: 0x2C3E00, symSize: 0xA8 }
-  - { offsetInCU: 0x90B, offset: 0x9EF08, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_reduce_once, symObjAddr: 0x18C, symBinAddr: 0x2C3E00, symSize: 0xA8 }
-  - { offsetInCU: 0xBAA, offset: 0x9F1A7, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_add_mod, symObjAddr: 0x234, symBinAddr: 0x2C3EA8, symSize: 0x110 }
-  - { offsetInCU: 0xC4C, offset: 0x9F249, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_add_mod, symObjAddr: 0x234, symBinAddr: 0x2C3EA8, symSize: 0x110 }
-  - { offsetInCU: 0xEDE, offset: 0x9F4DB, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_sub_mod, symObjAddr: 0x344, symBinAddr: 0x2C3FB8, symSize: 0xB0 }
-  - { offsetInCU: 0xF5E, offset: 0x9F55B, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_sub_mod, symObjAddr: 0x344, symBinAddr: 0x2C3FB8, symSize: 0xB0 }
-  - { offsetInCU: 0x10E1, offset: 0x9F6DE, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_shl_mod, symObjAddr: 0x3F4, symBinAddr: 0x2C4068, symSize: 0x178 }
-  - { offsetInCU: 0x13AB, offset: 0x9F9A8, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_select_512_32, symObjAddr: 0x56C, symBinAddr: 0x2C41E0, symSize: 0x1F4 }
-  - { offsetInCU: 0x1500, offset: 0x9FAFD, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_window5_split_window, symObjAddr: 0x760, symBinAddr: 0x2C43D4, symSize: 0x18 }
-  - { offsetInCU: 0x1567, offset: 0x9FB64, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_window5_unsplit_window, symObjAddr: 0x778, symBinAddr: 0x2C43EC, symSize: 0xC }
-  - { offsetInCU: 0x15A0, offset: 0x9FB9D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMB_shr, symObjAddr: 0x784, symBinAddr: 0x2C43F8, symSize: 0x8 }
-  - { offsetInCU: 0x1624, offset: 0x9FC21, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_limbs_mul_add_limb, symObjAddr: 0x78C, symBinAddr: 0x2C4400, symSize: 0x3C }
-  - { offsetInCU: 0x26, offset: 0x9FDD4, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_CRYPTO_memcmp, symObjAddr: 0x0, symBinAddr: 0x2C443C, symSize: 0x170 }
-  - { offsetInCU: 0x34, offset: 0x9FDE2, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_CRYPTO_memcmp, symObjAddr: 0x0, symBinAddr: 0x2C443C, symSize: 0x170 }
-  - { offsetInCU: 0x34, offset: 0x9FEE8, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_OPENSSL_armcap_P, symObjAddr: 0x374, symBinAddr: 0x10DAFE0, symSize: 0x0 }
-  - { offsetInCU: 0x26, offset: 0x9FF2A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul, symObjAddr: 0x0, symBinAddr: 0x2C45AC, symSize: 0x388 }
-  - { offsetInCU: 0x76, offset: 0x9FF7A, size: 0x8, addend: 0x0, symName: _ecp_nistz256_precomputed, symObjAddr: 0x1000, symBinAddr: 0x9AB000, symSize: 0x0 }
-  - { offsetInCU: 0xFA, offset: 0x9FFFE, size: 0x8, addend: 0x0, symName: _ONE, symObjAddr: 0x26000, symBinAddr: 0x9D0000, symSize: 0x0 }
-  - { offsetInCU: 0x35B, offset: 0xA025F, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul, symObjAddr: 0x0, symBinAddr: 0x2C45AC, symSize: 0x388 }
-  - { offsetInCU: 0xC66, offset: 0xA0B6A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul_base, symObjAddr: 0x388, symBinAddr: 0x2C4934, symSize: 0x204 }
-  - { offsetInCU: 0x1171, offset: 0xA1075, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul_base_vartime, symObjAddr: 0x58C, symBinAddr: 0x2C4B38, symSize: 0x1BC }
-  - { offsetInCU: 0x10, offset: 0xA144A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_set_encrypt_key, symObjAddr: 0x0, symBinAddr: 0x2C4D00, symSize: 0x1A0 }
-  - { offsetInCU: 0x50, offset: 0xA148A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_set_encrypt_key, symObjAddr: 0x0, symBinAddr: 0x2C4D00, symSize: 0x1A0 }
-  - { offsetInCU: 0x5E, offset: 0xA1498, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_encrypt, symObjAddr: 0x1A0, symBinAddr: 0x2C4EA0, symSize: 0x60 }
-  - { offsetInCU: 0x81, offset: 0xA14BB, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_ctr32_encrypt_blocks, symObjAddr: 0x200, symBinAddr: 0x2C4F00, symSize: 0x288 }
-  - { offsetInCU: 0x10, offset: 0xA14AC, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_init_clmul, symObjAddr: 0x0, symBinAddr: 0x2C5190, symSize: 0x130 }
-  - { offsetInCU: 0x48, offset: 0xA14E4, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_init_clmul, symObjAddr: 0x0, symBinAddr: 0x2C5190, symSize: 0x130 }
-  - { offsetInCU: 0x5F, offset: 0xA14FB, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_gmult_clmul, symObjAddr: 0x130, symBinAddr: 0x2C52C0, symSize: 0x70 }
-  - { offsetInCU: 0x75, offset: 0xA1511, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_ghash_clmul, symObjAddr: 0x1A0, symBinAddr: 0x2C5330, symSize: 0x160 }
-  - { offsetInCU: 0x7A, offset: 0xA1516, size: 0x8, addend: 0x0, symName: gcm_ghash_v8_4x, symObjAddr: 0x300, symBinAddr: 0x2C5490, symSize: 0x378 }
-  - { offsetInCU: 0x10, offset: 0xA1524, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ChaCha20_ctr32, symObjAddr: 0x0, symBinAddr: 0x2C5820, symSize: 0x3A0 }
-  - { offsetInCU: 0x48, offset: 0xA155C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ChaCha20_ctr32, symObjAddr: 0x0, symBinAddr: 0x2C5820, symSize: 0x3A0 }
-  - { offsetInCU: 0x4C, offset: 0xA1560, size: 0x8, addend: 0x0, symName: ChaCha20_neon, symObjAddr: 0x3A0, symBinAddr: 0x2C5BC0, symSize: 0x6C0 }
-  - { offsetInCU: 0x66, offset: 0xA157A, size: 0x8, addend: 0x0, symName: ChaCha20_512_neon, symObjAddr: 0xA60, symBinAddr: 0x2C6280, symSize: 0x1138 }
-  - { offsetInCU: 0x50, offset: 0xA15C6, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_chacha20_poly1305_seal, symObjAddr: 0x140, symBinAddr: 0x2C7500, symSize: 0x1180 }
-  - { offsetInCU: 0x66, offset: 0xA15DC, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_chacha20_poly1305_open, symObjAddr: 0x12C0, symBinAddr: 0x2C8680, symSize: 0x1410 }
-  - { offsetInCU: 0x10, offset: 0xA15D2, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_mul_mont, symObjAddr: 0x0, symBinAddr: 0x2C9AA0, symSize: 0x240 }
-  - { offsetInCU: 0x45, offset: 0xA1607, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_mul_mont, symObjAddr: 0x0, symBinAddr: 0x2C9AA0, symSize: 0x240 }
-  - { offsetInCU: 0x4D, offset: 0xA160F, size: 0x8, addend: 0x0, symName: __bn_sqr8x_mont, symObjAddr: 0x240, symBinAddr: 0x2C9CE0, symSize: 0x9E0 }
-  - { offsetInCU: 0x63, offset: 0xA1625, size: 0x8, addend: 0x0, symName: __bn_mul4x_mont, symObjAddr: 0xC20, symBinAddr: 0x2CA6C0, symSize: 0x650 }
-  - { offsetInCU: 0x10, offset: 0xA1634, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_mul_mont, symObjAddr: 0x0, symBinAddr: 0x2CAD20, symSize: 0x40 }
-  - { offsetInCU: 0x47, offset: 0xA166B, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_mul_mont, symObjAddr: 0x0, symBinAddr: 0x2CAD20, symSize: 0x40 }
-  - { offsetInCU: 0x5D, offset: 0xA1681, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_sqr_mont, symObjAddr: 0x40, symBinAddr: 0x2CAD60, symSize: 0x40 }
-  - { offsetInCU: 0x76, offset: 0xA169A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ecp_nistz256_neg, symObjAddr: 0x80, symBinAddr: 0x2CADA0, symSize: 0x40 }
-  - { offsetInCU: 0x81, offset: 0xA16A5, size: 0x8, addend: 0x0, symName: __ecp_nistz256_mul_mont, symObjAddr: 0xC0, symBinAddr: 0x2CADE0, symSize: 0x1E0 }
-  - { offsetInCU: 0x97, offset: 0xA16BB, size: 0x8, addend: 0x0, symName: __ecp_nistz256_sqr_mont, symObjAddr: 0x2A0, symBinAddr: 0x2CAFC0, symSize: 0x170 }
-  - { offsetInCU: 0xAB, offset: 0xA16CF, size: 0x8, addend: 0x0, symName: __ecp_nistz256_add_to, symObjAddr: 0x410, symBinAddr: 0x2CB130, symSize: 0x50 }
-  - { offsetInCU: 0xC3, offset: 0xA16E7, size: 0x8, addend: 0x0, symName: __ecp_nistz256_sub_from, symObjAddr: 0x460, symBinAddr: 0x2CB180, symSize: 0x50 }
-  - { offsetInCU: 0xD9, offset: 0xA16FD, size: 0x8, addend: 0x0, symName: __ecp_nistz256_sub_morf, symObjAddr: 0x4B0, symBinAddr: 0x2CB1D0, symSize: 0x50 }
-  - { offsetInCU: 0xEF, offset: 0xA1713, size: 0x8, addend: 0x0, symName: __ecp_nistz256_div_by_2, symObjAddr: 0x500, symBinAddr: 0x2CB220, symSize: 0x60 }
-  - { offsetInCU: 0x111, offset: 0xA1735, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_double, symObjAddr: 0x560, symBinAddr: 0x2CB280, symSize: 0x1E0 }
-  - { offsetInCU: 0x124, offset: 0xA1748, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_add, symObjAddr: 0x740, symBinAddr: 0x2CB460, symSize: 0x360 }
-  - { offsetInCU: 0x141, offset: 0xA1765, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_add_affine, symObjAddr: 0xAA0, symBinAddr: 0x2CB7C0, symSize: 0x2D0 }
-  - { offsetInCU: 0x156, offset: 0xA177A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_scalar_mul_mont, symObjAddr: 0xD70, symBinAddr: 0x2CBA90, symSize: 0x2B0 }
-  - { offsetInCU: 0x170, offset: 0xA1794, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_scalar_sqr_rep_mont, symObjAddr: 0x1020, symBinAddr: 0x2CBD40, symSize: 0x250 }
-  - { offsetInCU: 0x184, offset: 0xA17A8, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ecp_nistz256_select_w5, symObjAddr: 0x1270, symBinAddr: 0x2CBF90, symSize: 0x60 }
-  - { offsetInCU: 0x19A, offset: 0xA17BE, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ecp_nistz256_select_w7, symObjAddr: 0x12D0, symBinAddr: 0x2CBFF0, symSize: 0x44 }
-  - { offsetInCU: 0x10, offset: 0xA17B4, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_gcm_enc_kernel, symObjAddr: 0x0, symBinAddr: 0x2CC040, symSize: 0xB90 }
-  - { offsetInCU: 0x4C, offset: 0xA17F0, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_gcm_enc_kernel, symObjAddr: 0x0, symBinAddr: 0x2CC040, symSize: 0xB90 }
-  - { offsetInCU: 0x62, offset: 0xA1806, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_gcm_dec_kernel, symObjAddr: 0xB90, symBinAddr: 0x2CCBD0, symSize: 0xB98 }
-  - { offsetInCU: 0x10, offset: 0xA1800, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha512_block_data_order, symObjAddr: 0x0, symBinAddr: 0x2CD780, symSize: 0xE40 }
-  - { offsetInCU: 0x51, offset: 0xA1841, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha512_block_data_order, symObjAddr: 0x0, symBinAddr: 0x2CD780, symSize: 0xE40 }
-  - { offsetInCU: 0x51, offset: 0xA1841, size: 0x8, addend: 0x0, symName: sha512_block_armv8, symObjAddr: 0xE40, symBinAddr: 0x2CE5C0, symSize: 0x7E0 }
-  - { offsetInCU: 0x10, offset: 0xA184C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha256_block_data_order, symObjAddr: 0x0, symBinAddr: 0x2CEDC0, symSize: 0xE40 }
-  - { offsetInCU: 0x51, offset: 0xA188D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha256_block_data_order, symObjAddr: 0x0, symBinAddr: 0x2CEDC0, symSize: 0xE40 }
-  - { offsetInCU: 0x51, offset: 0xA188D, size: 0x8, addend: 0x0, symName: sha256_block_armv8, symObjAddr: 0xE40, symBinAddr: 0x2CFC00, symSize: 0x1F0 }
+  - { offsetInCU: 0x34, offset: 0x7789E, size: 0x8, addend: 0x0, symName: _CanvasNativeVersionString, symObjAddr: 0x0, symBinAddr: 0x965000, symSize: 0x0 }
+  - { offsetInCU: 0x69, offset: 0x778D3, size: 0x8, addend: 0x0, symName: _CanvasNativeVersionNumber, symObjAddr: 0x38, symBinAddr: 0x965038, symSize: 0x0 }
+  - { offsetInCU: 0x3F, offset: 0x77928, size: 0x8, addend: 0x0, symName: ___swift_memcpy16_8, symObjAddr: 0x28, symBinAddr: 0x8028, symSize: 0xC }
+  - { offsetInCU: 0x53, offset: 0x7793C, size: 0x8, addend: 0x0, symName: ___swift_noop_void_return, symObjAddr: 0x34, symBinAddr: 0x8034, symSize: 0x4 }
+  - { offsetInCU: 0x67, offset: 0x77950, size: 0x8, addend: 0x0, symName: '_$sSo6CGSizeVwet', symObjAddr: 0x38, symBinAddr: 0x8038, symSize: 0x20 }
+  - { offsetInCU: 0x7B, offset: 0x77964, size: 0x8, addend: 0x0, symName: '_$sSo6CGSizeVwst', symObjAddr: 0x58, symBinAddr: 0x8058, symSize: 0x28 }
+  - { offsetInCU: 0x8F, offset: 0x77978, size: 0x8, addend: 0x0, symName: '_$sSo6CGRectVwCP', symObjAddr: 0x94, symBinAddr: 0x8094, symSize: 0x30 }
+  - { offsetInCU: 0xA3, offset: 0x7798C, size: 0x8, addend: 0x0, symName: ___swift_memcpy32_8, symObjAddr: 0xC4, symBinAddr: 0x80C4, symSize: 0xC }
+  - { offsetInCU: 0xB7, offset: 0x779A0, size: 0x8, addend: 0x0, symName: '_$sSo6CGRectVwet', symObjAddr: 0xD0, symBinAddr: 0x80D0, symSize: 0x20 }
+  - { offsetInCU: 0xCB, offset: 0x779B4, size: 0x8, addend: 0x0, symName: '_$sSo6CGRectVwst', symObjAddr: 0xF0, symBinAddr: 0x80F0, symSize: 0x2C }
+  - { offsetInCU: 0x4F, offset: 0x77B9D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC11_WriteQueue33_05178D28796EA758448493B56DC45144LLSo011NSOperationE0CSgvpZ', symObjAddr: 0x2AE8, symBinAddr: 0x115E520, symSize: 0x0 }
+  - { offsetInCU: 0x69, offset: 0x77BB7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10_ReadQueue33_05178D28796EA758448493B56DC45144LLSo011NSOperationE0CSgvpZ', symObjAddr: 0x2AF0, symBinAddr: 0x115E528, symSize: 0x0 }
+  - { offsetInCU: 0x9D, offset: 0x77BEB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC19getBytesFromUIImageySo13NSMutableDataCSo0G0CFZTo', symObjAddr: 0x4, symBinAddr: 0x8194, symSize: 0x38 }
+  - { offsetInCU: 0xF3, offset: 0x77C41, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13createPatternys5Int64VAF_So7UIImageCSStFZTo', symObjAddr: 0x40, symBinAddr: 0x81D0, symSize: 0x70 }
+  - { offsetInCU: 0x144, offset: 0x77C92, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC25loadImageAssetWithContextySbs5Int64V_So7UIImageCtFZTo', symObjAddr: 0xB4, symBinAddr: 0x8244, symSize: 0x44 }
+  - { offsetInCU: 0x19F, offset: 0x77CED, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dyys5Int64V_So7UIImageCS2ftFZTo', symObjAddr: 0xFC, symBinAddr: 0x828C, symSize: 0x50 }
+  - { offsetInCU: 0x204, offset: 0x77D52, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dy2dw2dhys5Int64V_So7UIImageCS4ftFZTo', symObjAddr: 0x150, symBinAddr: 0x82E0, symSize: 0x68 }
+  - { offsetInCU: 0x27D, offset: 0x77DCB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2sx2sy2sw2sh2dx2dy2dw2dhys5Int64V_So7UIImageCS8ftFZTo', symObjAddr: 0x1BC, symBinAddr: 0x834C, symSize: 0x98 }
+  - { offsetInCU: 0x2DA, offset: 0x77E28, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23initWebGPUWithViewLayerys5Int64VAF_AFs6UInt32VAHtFZTo', symObjAddr: 0x258, symBinAddr: 0x83E8, symSize: 0x14 }
+  - { offsetInCU: 0x35C, offset: 0x77EAA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC18initWebGPUWithViewys5Int64VAF_AFs6UInt32VAHtFZTo', symObjAddr: 0x270, symBinAddr: 0x8400, symSize: 0x14 }
+  - { offsetInCU: 0x40B, offset: 0x77F59, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14initGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbtFZTo', symObjAddr: 0x2C8, symBinAddr: 0x8458, symSize: 0x50 }
+  - { offsetInCU: 0x4DC, offset: 0x7802A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC20initSharedGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbAFtFZTo', symObjAddr: 0x364, symBinAddr: 0x84F4, symSize: 0x58 }
+  - { offsetInCU: 0x5B6, offset: 0x78104, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC24initGLWithWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbtFZTo', symObjAddr: 0x404, symBinAddr: 0x8594, symSize: 0x58 }
+  - { offsetInCU: 0x695, offset: 0x781E3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC26initSharedGLWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbAFtFZTo', symObjAddr: 0x4AC, symBinAddr: 0x863C, symSize: 0x60 }
+  - { offsetInCU: 0x741, offset: 0x7828F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15resize2DContextyys5Int64V_S2ftFZTo', symObjAddr: 0x510, symBinAddr: 0x86A0, symSize: 0x8 }
+  - { offsetInCU: 0x7AA, offset: 0x782F8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14flush2DContextyys5Int64VFZTo', symObjAddr: 0x51C, symBinAddr: 0x86AC, symSize: 0x8 }
+  - { offsetInCU: 0x801, offset: 0x7834F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC7flushGLySbs5Int64VFZTo', symObjAddr: 0x538, symBinAddr: 0x86C8, symSize: 0x8 }
+  - { offsetInCU: 0x858, offset: 0x783A6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9releaseGLyys5Int64VFZTo', symObjAddr: 0x544, symBinAddr: 0x86D4, symSize: 0x8 }
+  - { offsetInCU: 0x8AF, offset: 0x783FD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC12getGLPointerys5Int64VAFFZTo', symObjAddr: 0x550, symBinAddr: 0x86E0, symSize: 0x8 }
+  - { offsetInCU: 0x906, offset: 0x78454, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC16releaseGLPointeryys5Int64VFZTo', symObjAddr: 0x55C, symBinAddr: 0x86EC, symSize: 0x8 }
+  - { offsetInCU: 0x985, offset: 0x784D3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15create2DContextys5Int64VAF_s5Int32VAHSbSfA2HSfAHtFZTo', symObjAddr: 0x56C, symBinAddr: 0x86FC, symSize: 0x24 }
+  - { offsetInCU: 0xA36, offset: 0x78584, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23updateGLSurfaceWithViewyys5Int64V_s5Int32VAhFtFZTo', symObjAddr: 0x594, symBinAddr: 0x8724, symSize: 0x14 }
+  - { offsetInCU: 0xAA9, offset: 0x785F7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC6test2Dyys5Int64VFZTo', symObjAddr: 0x5AC, symBinAddr: 0x873C, symSize: 0x8 }
+  - { offsetInCU: 0xB00, offset: 0x7864E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13testToDataURLySSs5Int64VFZTo', symObjAddr: 0x60C, symBinAddr: 0x879C, symSize: 0x74 }
+  - { offsetInCU: 0xB8B, offset: 0x786D9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZTo', symObjAddr: 0x814, symBinAddr: 0x89A4, symSize: 0xA0 }
+  - { offsetInCU: 0xBDC, offset: 0x7872A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZTo', symObjAddr: 0xB1C, symBinAddr: 0x8CAC, symSize: 0x98 }
+  - { offsetInCU: 0xC2D, offset: 0x7877B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZTo', symObjAddr: 0xE70, symBinAddr: 0x9000, symSize: 0x98 }
+  - { offsetInCU: 0xC89, offset: 0x787D7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZTo', symObjAddr: 0x1298, symBinAddr: 0x9428, symSize: 0xD8 }
+  - { offsetInCU: 0xCD1, offset: 0x7881F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC32getPixelsPerInchForCurrentDeviceSSyFZTo', symObjAddr: 0x1374, symBinAddr: 0x9504, symSize: 0x34 }
+  - { offsetInCU: 0xD31, offset: 0x7887F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCACycfcTo', symObjAddr: 0x13F8, symBinAddr: 0x9588, symSize: 0x3C }
+  - { offsetInCU: 0xD82, offset: 0x788D0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC19getBytesFromUIImageySo13NSMutableDataCSo0G0CFZTf4nd_n', symObjAddr: 0x1468, symBinAddr: 0x95F8, symSize: 0x2AC }
+  - { offsetInCU: 0xFB6, offset: 0x78B04, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13createPatternys5Int64VAF_So7UIImageCSStFZTf4nnnd_n', symObjAddr: 0x1714, symBinAddr: 0x98A4, symSize: 0x264 }
+  - { offsetInCU: 0x11B0, offset: 0x78CFE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC25loadImageAssetWithContextySbs5Int64V_So7UIImageCtFZTf4nnd_n', symObjAddr: 0x1978, symBinAddr: 0x9B08, symSize: 0xEC }
+  - { offsetInCU: 0x12AD, offset: 0x78DFB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dyys5Int64V_So7UIImageCS2ftFZTf4nnnnd_n', symObjAddr: 0x1A64, symBinAddr: 0x9BF4, symSize: 0x1B4 }
+  - { offsetInCU: 0x1422, offset: 0x78F70, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dy2dw2dhys5Int64V_So7UIImageCS4ftFZTf4nnnnnnd_n', symObjAddr: 0x1C18, symBinAddr: 0x9DA8, symSize: 0x1CC }
+  - { offsetInCU: 0x15B7, offset: 0x79105, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2sx2sy2sw2sh2dx2dy2dw2dhys5Int64V_So7UIImageCS8ftFZTf4nnnnnnnnnnd_n', symObjAddr: 0x1DE4, symBinAddr: 0x9F74, symSize: 0x1E0 }
+  - { offsetInCU: 0x17A3, offset: 0x792F1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZTf4nnnd_n', symObjAddr: 0x1FC4, symBinAddr: 0xA154, symSize: 0x1B4 }
+  - { offsetInCU: 0x186D, offset: 0x793BB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZTf4nnnnd_n', symObjAddr: 0x231C, symBinAddr: 0xA4AC, symSize: 0x1D4 }
+  - { offsetInCU: 0x194E, offset: 0x7949C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC32getPixelsPerInchForCurrentDeviceSSyFZTf4d_n', symObjAddr: 0x24F0, symBinAddr: 0xA680, symSize: 0x114 }
+  - { offsetInCU: 0x19F9, offset: 0x79547, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgACIeyByy_SSSgADIeggg_TR', symObjAddr: 0x8B4, symBinAddr: 0x8A44, symSize: 0x78 }
+  - { offsetInCU: 0x1A11, offset: 0x7955F, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgSo6NSDataCSgIeyByy_SSSgAFIeggg_TR', symObjAddr: 0xBB4, symBinAddr: 0x8D44, symSize: 0x54 }
+  - { offsetInCU: 0x1A7E, offset: 0x795CC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCfETo', symObjAddr: 0x1464, symBinAddr: 0x95F4, symSize: 0x4 }
+  - { offsetInCU: 0x1B09, offset: 0x79657, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCMa', symObjAddr: 0x2604, symBinAddr: 0xA794, symSize: 0x20 }
+  - { offsetInCU: 0x1B1D, offset: 0x7966B, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgACIeyByy_SSSgADIeggg_TRTA', symObjAddr: 0x2648, symBinAddr: 0xA7D8, symSize: 0x8 }
+  - { offsetInCU: 0x1B3C, offset: 0x7968A, size: 0x8, addend: 0x0, symName: '_$sSo7NSErrorCSg10ObjectiveC8ObjCBoolVIeyByy_ACSbIeggy_TRTA', symObjAddr: 0x2650, symBinAddr: 0xA7E0, symSize: 0x18 }
+  - { offsetInCU: 0x1B65, offset: 0x796B3, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgSo6NSDataCSgIeyByy_SSSgAFIeggg_TRTA', symObjAddr: 0x2668, symBinAddr: 0xA7F8, symSize: 0x8 }
+  - { offsetInCU: 0x1B79, offset: 0x796C7, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCMa', symObjAddr: 0x2670, symBinAddr: 0xA800, symSize: 0x3C }
+  - { offsetInCU: 0x1B8D, offset: 0x796DB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZyyYbcfU_TA', symObjAddr: 0x26F0, symBinAddr: 0xA880, symSize: 0x34 }
+  - { offsetInCU: 0x1BA1, offset: 0x796EF, size: 0x8, addend: 0x0, symName: _block_copy_helper, symObjAddr: 0x2724, symBinAddr: 0xA8B4, symSize: 0x10 }
+  - { offsetInCU: 0x1BB5, offset: 0x79703, size: 0x8, addend: 0x0, symName: _block_destroy_helper, symObjAddr: 0x2734, symBinAddr: 0xA8C4, symSize: 0x8 }
+  - { offsetInCU: 0x1BC9, offset: 0x79717, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZyyYbcfU_yyYbcfU0_TA', symObjAddr: 0x2760, symBinAddr: 0xA8F0, symSize: 0x40 }
+  - { offsetInCU: 0x1BFD, offset: 0x7974B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZyyYbcfU_yyYbcfU0_TA', symObjAddr: 0x27E4, symBinAddr: 0xA974, symSize: 0x40 }
+  - { offsetInCU: 0x1C3B, offset: 0x79789, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZyyYbcfU_yyYbcfU_TA', symObjAddr: 0x2824, symBinAddr: 0xA9B4, symSize: 0x28 }
+  - { offsetInCU: 0x1C6F, offset: 0x797BD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZyyYbcfU_yyYbcfU_TA', symObjAddr: 0x28A4, symBinAddr: 0xAA34, symSize: 0x3C }
+  - { offsetInCU: 0x1CA3, offset: 0x797F1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZyyYbcfU_yyYbcfU0_TA', symObjAddr: 0x290C, symBinAddr: 0xAA9C, symSize: 0x30 }
+  - { offsetInCU: 0x1CDF, offset: 0x7982D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZyyYbcfU_TA', symObjAddr: 0x2978, symBinAddr: 0xAB08, symSize: 0x10 }
+  - { offsetInCU: 0x1CF3, offset: 0x79841, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZyyYbcfU_yyYbcfU_TA', symObjAddr: 0x2988, symBinAddr: 0xAB18, symSize: 0x40 }
+  - { offsetInCU: 0x21C0, offset: 0x79D0E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC19getBytesFromUIImageySo13NSMutableDataCSo0G0CFZ', symObjAddr: 0x0, symBinAddr: 0x8190, symSize: 0x4 }
+  - { offsetInCU: 0x21DB, offset: 0x79D29, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x3C, symBinAddr: 0x81CC, symSize: 0x4 }
+  - { offsetInCU: 0x21F6, offset: 0x79D44, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC25loadImageAssetWithContextySbs5Int64V_So7UIImageCtFZ', symObjAddr: 0xB0, symBinAddr: 0x8240, symSize: 0x4 }
+  - { offsetInCU: 0x2217, offset: 0x79D65, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dyys5Int64V_So7UIImageCS2ftFZ', symObjAddr: 0xF8, symBinAddr: 0x8288, symSize: 0x4 }
+  - { offsetInCU: 0x2232, offset: 0x79D80, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dy2dw2dhys5Int64V_So7UIImageCS4ftFZ', symObjAddr: 0x14C, symBinAddr: 0x82DC, symSize: 0x4 }
+  - { offsetInCU: 0x224D, offset: 0x79D9B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2sx2sy2sw2sh2dx2dy2dw2dhys5Int64V_So7UIImageCS8ftFZ', symObjAddr: 0x1B8, symBinAddr: 0x8348, symSize: 0x4 }
+  - { offsetInCU: 0x2268, offset: 0x79DB6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23initWebGPUWithViewLayerys5Int64VAF_AFs6UInt32VAHtFZ', symObjAddr: 0x254, symBinAddr: 0x83E4, symSize: 0x4 }
+  - { offsetInCU: 0x22F6, offset: 0x79E44, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC18initWebGPUWithViewys5Int64VAF_AFs6UInt32VAHtFZ', symObjAddr: 0x26C, symBinAddr: 0x83FC, symSize: 0x4 }
+  - { offsetInCU: 0x2375, offset: 0x79EC3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14initGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbtFZ', symObjAddr: 0x284, symBinAddr: 0x8414, symSize: 0x44 }
+  - { offsetInCU: 0x24B3, offset: 0x7A001, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC20initSharedGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbAFtFZ', symObjAddr: 0x318, symBinAddr: 0x84A8, symSize: 0x4C }
+  - { offsetInCU: 0x25FC, offset: 0x7A14A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC24initGLWithWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbtFZ', symObjAddr: 0x3BC, symBinAddr: 0x854C, symSize: 0x48 }
+  - { offsetInCU: 0x2744, offset: 0x7A292, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC26initSharedGLWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbAFtFZ', symObjAddr: 0x45C, symBinAddr: 0x85EC, symSize: 0x50 }
+  - { offsetInCU: 0x28A1, offset: 0x7A3EF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15resize2DContextyys5Int64V_S2ftFZ', symObjAddr: 0x50C, symBinAddr: 0x869C, symSize: 0x4 }
+  - { offsetInCU: 0x2913, offset: 0x7A461, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14flush2DContextyys5Int64VFZ', symObjAddr: 0x518, symBinAddr: 0x86A8, symSize: 0x4 }
+  - { offsetInCU: 0x2956, offset: 0x7A4A4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC7flushGLySbs5Int64VFZ', symObjAddr: 0x524, symBinAddr: 0x86B4, symSize: 0x14 }
+  - { offsetInCU: 0x299B, offset: 0x7A4E9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9releaseGLyys5Int64VFZ', symObjAddr: 0x540, symBinAddr: 0x86D0, symSize: 0x4 }
+  - { offsetInCU: 0x29DE, offset: 0x7A52C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC12getGLPointerys5Int64VAFFZ', symObjAddr: 0x54C, symBinAddr: 0x86DC, symSize: 0x4 }
+  - { offsetInCU: 0x2A21, offset: 0x7A56F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC16releaseGLPointeryys5Int64VFZ', symObjAddr: 0x558, symBinAddr: 0x86E8, symSize: 0x4 }
+  - { offsetInCU: 0x2A64, offset: 0x7A5B2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15create2DContextys5Int64VAF_s5Int32VAHSbSfA2HSfAHtFZ', symObjAddr: 0x564, symBinAddr: 0x86F4, symSize: 0x8 }
+  - { offsetInCU: 0x2B4B, offset: 0x7A699, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23updateGLSurfaceWithViewyys5Int64V_s5Int32VAhFtFZ', symObjAddr: 0x590, symBinAddr: 0x8720, symSize: 0x4 }
+  - { offsetInCU: 0x2BCA, offset: 0x7A718, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC6test2Dyys5Int64VFZ', symObjAddr: 0x5A8, symBinAddr: 0x8738, symSize: 0x4 }
+  - { offsetInCU: 0x2C0D, offset: 0x7A75B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13testToDataURLySSs5Int64VFZ', symObjAddr: 0x5B4, symBinAddr: 0x8744, symSize: 0x58 }
+  - { offsetInCU: 0x2CCE, offset: 0x7A81C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZ', symObjAddr: 0x680, symBinAddr: 0x8810, symSize: 0x4 }
+  - { offsetInCU: 0x2CE2, offset: 0x7A830, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZyyYbcfU_', symObjAddr: 0x684, symBinAddr: 0x8814, symSize: 0x190 }
+  - { offsetInCU: 0x2D82, offset: 0x7A8D0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZ', symObjAddr: 0x92C, symBinAddr: 0x8ABC, symSize: 0x2C }
+  - { offsetInCU: 0x2D96, offset: 0x7A8E4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZyyYbcfU_', symObjAddr: 0x958, symBinAddr: 0x8AE8, symSize: 0x1C4 }
+  - { offsetInCU: 0x2E80, offset: 0x7A9CE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZ', symObjAddr: 0xC08, symBinAddr: 0x8D98, symSize: 0x2C }
+  - { offsetInCU: 0x2E94, offset: 0x7A9E2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZyyYbcfU_', symObjAddr: 0xC34, symBinAddr: 0x8DC4, symSize: 0x23C }
+  - { offsetInCU: 0x2F48, offset: 0x7AA96, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZ', symObjAddr: 0xF08, symBinAddr: 0x9098, symSize: 0x4 }
+  - { offsetInCU: 0x2F5C, offset: 0x7AAAA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZyyYbcfU_', symObjAddr: 0xF0C, symBinAddr: 0x909C, symSize: 0x38C }
+  - { offsetInCU: 0x31F3, offset: 0x7AD41, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC32getPixelsPerInchForCurrentDeviceSSyFZ', symObjAddr: 0x1370, symBinAddr: 0x9500, symSize: 0x4 }
+  - { offsetInCU: 0x320E, offset: 0x7AD5C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCACycfC', symObjAddr: 0x13A8, symBinAddr: 0x9538, symSize: 0x20 }
+  - { offsetInCU: 0x3222, offset: 0x7AD70, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCACycfc', symObjAddr: 0x13C8, symBinAddr: 0x9558, symSize: 0x30 }
+  - { offsetInCU: 0x3258, offset: 0x7ADA6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCfD', symObjAddr: 0x1434, symBinAddr: 0x95C4, symSize: 0x30 }
+  - { offsetInCU: 0x4F, offset: 0x7AFDE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19shared_context_view33_508084857CA7D194CA72FEB80DD78002LLSo7GLKViewCvpZ', symObjAddr: 0x55E0, symBinAddr: 0x115E560, symSize: 0x0 }
+  - { offsetInCU: 0x69, offset: 0x7AFF8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15_shared_context33_508084857CA7D194CA72FEB80DD78002LLs5Int64VvpZ', symObjAddr: 0x55E8, symBinAddr: 0x115E568, symSize: 0x0 }
+  - { offsetInCU: 0x83, offset: 0x7B012, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5storeSo19NSMutableDictionaryCvpZ', symObjAddr: 0x55F0, symBinAddr: 0x115E570, symSize: 0x0 }
+  - { offsetInCU: 0x9D, offset: 0x7B02C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5views33_508084857CA7D194CA72FEB80DD78002LLSo10NSMapTableCySo8NSStringCACGvpZ', symObjAddr: 0x55F8, symBinAddr: 0x115E578, symSize: 0x0 }
+  - { offsetInCU: 0xAB, offset: 0x7B03A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19shared_context_view33_508084857CA7D194CA72FEB80DD78002LL_WZ', symObjAddr: 0x0, symBinAddr: 0xAC40, symSize: 0x40 }
+  - { offsetInCU: 0xF0, offset: 0x7B07F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5store_WZ', symObjAddr: 0x40, symBinAddr: 0xAC80, symSize: 0x30 }
+  - { offsetInCU: 0x135, offset: 0x7B0C4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5views33_508084857CA7D194CA72FEB80DD78002LL_WZ', symObjAddr: 0xA8, symBinAddr: 0xACE8, symSize: 0x40 }
+  - { offsetInCU: 0x187, offset: 0x7B116, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC3ptrSvSgvgTo', symObjAddr: 0x194, symBinAddr: 0xADD4, symSize: 0x10 }
+  - { offsetInCU: 0x1A7, offset: 0x7B136, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC3ptrSvSgvgTo', symObjAddr: 0x194, symBinAddr: 0xADD4, symSize: 0x10 }
+  - { offsetInCU: 0x1DD, offset: 0x7B16C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC3ptrSvSgvsTo', symObjAddr: 0x1A4, symBinAddr: 0xADE4, symSize: 0x10 }
+  - { offsetInCU: 0x1FD, offset: 0x7B18C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC3ptrSvSgvsTo', symObjAddr: 0x1A4, symBinAddr: 0xADE4, symSize: 0x10 }
+  - { offsetInCU: 0x236, offset: 0x7B1C5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6mtlPtrSvSgvgTo', symObjAddr: 0x1B4, symBinAddr: 0xADF4, symSize: 0x10 }
+  - { offsetInCU: 0x256, offset: 0x7B1E5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6mtlPtrSvSgvgTo', symObjAddr: 0x1B4, symBinAddr: 0xADF4, symSize: 0x10 }
+  - { offsetInCU: 0x28C, offset: 0x7B21B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6mtlPtrSvSgvsTo', symObjAddr: 0x1C4, symBinAddr: 0xAE04, symSize: 0x10 }
+  - { offsetInCU: 0x2AC, offset: 0x7B23B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6mtlPtrSvSgvsTo', symObjAddr: 0x1C4, symBinAddr: 0xAE04, symSize: 0x10 }
+  - { offsetInCU: 0x2E5, offset: 0x7B274, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvgTo', symObjAddr: 0x29C, symBinAddr: 0xAEDC, symSize: 0x44 }
+  - { offsetInCU: 0x322, offset: 0x7B2B1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvsTo', symObjAddr: 0x324, symBinAddr: 0xAF64, symSize: 0x30 }
+  - { offsetInCU: 0x3B1, offset: 0x7B340, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8nativeGLs5Int64VvgTo', symObjAddr: 0x578, symBinAddr: 0xB1B8, symSize: 0x44 }
+  - { offsetInCU: 0x409, offset: 0x7B398, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8nativeGLs5Int64VvsTo', symObjAddr: 0x600, symBinAddr: 0xB240, symSize: 0x48 }
+  - { offsetInCU: 0x464, offset: 0x7B3F3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13nativeContexts5Int64VvgTo', symObjAddr: 0x648, symBinAddr: 0xB288, symSize: 0x44 }
+  - { offsetInCU: 0x4BC, offset: 0x7B44B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13nativeContexts5Int64VvsTo', symObjAddr: 0x6D0, symBinAddr: 0xB310, symSize: 0x48 }
+  - { offsetInCU: 0x517, offset: 0x7B4A6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15native2DContexts5Int64VvgTo', symObjAddr: 0x718, symBinAddr: 0xB358, symSize: 0x10 }
+  - { offsetInCU: 0x537, offset: 0x7B4C6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15native2DContexts5Int64VvgTo', symObjAddr: 0x718, symBinAddr: 0xB358, symSize: 0x10 }
+  - { offsetInCU: 0x56D, offset: 0x7B4FC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15native2DContexts5Int64VvsTo', symObjAddr: 0x728, symBinAddr: 0xB368, symSize: 0x10 }
+  - { offsetInCU: 0x58D, offset: 0x7B51C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15native2DContexts5Int64VvsTo', symObjAddr: 0x728, symBinAddr: 0xB368, symSize: 0x10 }
+  - { offsetInCU: 0x5C6, offset: 0x7B555, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7mtlViewSo7MTKViewCvgTo', symObjAddr: 0x738, symBinAddr: 0xB378, symSize: 0x10 }
+  - { offsetInCU: 0x5E6, offset: 0x7B575, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7mtlViewSo7MTKViewCvgTo', symObjAddr: 0x738, symBinAddr: 0xB378, symSize: 0x10 }
+  - { offsetInCU: 0x61E, offset: 0x7B5AD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7mtlViewSo7MTKViewCvsTo', symObjAddr: 0x748, symBinAddr: 0xB388, symSize: 0x34 }
+  - { offsetInCU: 0x677, offset: 0x7B606, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7glkViewAA0A7GLKViewCvgTo', symObjAddr: 0x77C, symBinAddr: 0xB3BC, symSize: 0x10 }
+  - { offsetInCU: 0x697, offset: 0x7B626, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7glkViewAA0A7GLKViewCvgTo', symObjAddr: 0x77C, symBinAddr: 0xB3BC, symSize: 0x10 }
+  - { offsetInCU: 0x6CF, offset: 0x7B65E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7glkViewAA0A7GLKViewCvsTo', symObjAddr: 0x78C, symBinAddr: 0xB3CC, symSize: 0x34 }
+  - { offsetInCU: 0x728, offset: 0x7B6B7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC4is2DSbvgTo', symObjAddr: 0x7C0, symBinAddr: 0xB400, symSize: 0x10 }
+  - { offsetInCU: 0x748, offset: 0x7B6D7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC4is2DSbvgTo', symObjAddr: 0x7C0, symBinAddr: 0xB400, symSize: 0x10 }
+  - { offsetInCU: 0x77E, offset: 0x7B70D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC4is2DSbvsTo', symObjAddr: 0x7D0, symBinAddr: 0xB410, symSize: 0x10 }
+  - { offsetInCU: 0x79E, offset: 0x7B72D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC4is2DSbvsTo', symObjAddr: 0x7D0, symBinAddr: 0xB410, symSize: 0x10 }
+  - { offsetInCU: 0x7D7, offset: 0x7B766, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7isMetalSbvgTo', symObjAddr: 0x7E0, symBinAddr: 0xB420, symSize: 0x10 }
+  - { offsetInCU: 0x7F7, offset: 0x7B786, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7isMetalSbvgTo', symObjAddr: 0x7E0, symBinAddr: 0xB420, symSize: 0x10 }
+  - { offsetInCU: 0x82D, offset: 0x7B7BC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7isMetalSbvsTo', symObjAddr: 0x7F0, symBinAddr: 0xB430, symSize: 0x10 }
+  - { offsetInCU: 0x84D, offset: 0x7B7DC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7isMetalSbvsTo', symObjAddr: 0x7F0, symBinAddr: 0xB430, symSize: 0x10 }
+  - { offsetInCU: 0x870, offset: 0x7B7FF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18drawingBufferWidthSivgTo', symObjAddr: 0x800, symBinAddr: 0xB440, symSize: 0x34 }
+  - { offsetInCU: 0x8A2, offset: 0x7B831, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19drawingBufferHeightSivgTo', symObjAddr: 0x904, symBinAddr: 0xB544, symSize: 0x34 }
+  - { offsetInCU: 0x8EA, offset: 0x7B879, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5widthSfvgTo', symObjAddr: 0xA08, symBinAddr: 0xB648, symSize: 0x20 }
+  - { offsetInCU: 0x952, offset: 0x7B8E1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6heightSfvgTo', symObjAddr: 0xA4C, symBinAddr: 0xB68C, symSize: 0x20 }
+  - { offsetInCU: 0x9F1, offset: 0x7B980, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11initContextyySS_S4bs5Int32VS5btFTo', symObjAddr: 0xAB4, symBinAddr: 0xB6F4, symSize: 0xC4 }
+  - { offsetInCU: 0xAB4, offset: 0x7BA43, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17initWebGPUContextyys5Int64VFTo', symObjAddr: 0xD10, symBinAddr: 0xB950, symSize: 0x30 }
+  - { offsetInCU: 0xB64, offset: 0x7BAF3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC015initContextWithE10AttributesyySS_S4bs5Int32VS5btFTo', symObjAddr: 0x15C8, symBinAddr: 0xC208, symSize: 0xC4 }
+  - { offsetInCU: 0xBCE, offset: 0x7BB5D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15create2DContextys5Int64VSb_S3bs5Int32VS5bAHtFTo', symObjAddr: 0x18E4, symBinAddr: 0xC524, symSize: 0xB0 }
+  - { offsetInCU: 0xC0B, offset: 0x7BB9A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11forceLayoutyy12CoreGraphics7CGFloatV_AGtFTo', symObjAddr: 0x1A54, symBinAddr: 0xC694, symSize: 0xB8 }
+  - { offsetInCU: 0xC83, offset: 0x7BC12, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8snapshotySo7UIImageCSgSbFTo', symObjAddr: 0x1BF0, symBinAddr: 0xC830, symSize: 0x3C }
+  - { offsetInCU: 0xCB6, offset: 0x7BC45, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8rendererAA9NSCRenderCSgvgTo', symObjAddr: 0x1C2C, symBinAddr: 0xC86C, symSize: 0x10 }
+  - { offsetInCU: 0xCD6, offset: 0x7BC65, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8rendererAA9NSCRenderCSgvgTo', symObjAddr: 0x1C2C, symBinAddr: 0xC86C, symSize: 0x10 }
+  - { offsetInCU: 0xD10, offset: 0x7BC9F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8rendererAA9NSCRenderCSgvsTo', symObjAddr: 0x1C3C, symBinAddr: 0xC87C, symSize: 0x34 }
+  - { offsetInCU: 0xD6B, offset: 0x7BCFA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6renderSbyFTo', symObjAddr: 0x1CB8, symBinAddr: 0xC8F8, symSize: 0x48 }
+  - { offsetInCU: 0xE05, offset: 0x7BD94, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13context2DTestyys5Int64VFTo', symObjAddr: 0x1D4C, symBinAddr: 0xC98C, symSize: 0x64 }
+  - { offsetInCU: 0xECA, offset: 0x7BE59, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC22context2DTestToDataURLySSs5Int64VFTo', symObjAddr: 0x1E08, symBinAddr: 0xCA48, symSize: 0x94 }
+  - { offsetInCU: 0xF57, offset: 0x7BEE6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC23enterBackgroundListeneryycSgvsTo', symObjAddr: 0x1EDC, symBinAddr: 0xCB1C, symSize: 0x6C }
+  - { offsetInCU: 0xFB9, offset: 0x7BF48, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC20becomeActiveListeneryycSgvsTo', symObjAddr: 0x1FEC, symBinAddr: 0xCC2C, symSize: 0x6C }
+  - { offsetInCU: 0x1016, offset: 0x7BFA5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvgTo', symObjAddr: 0x2058, symBinAddr: 0xCC98, symSize: 0xB0 }
+  - { offsetInCU: 0x1068, offset: 0x7BFF7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvsTo', symObjAddr: 0x21D8, symBinAddr: 0xCE18, symSize: 0x94 }
+  - { offsetInCU: 0x10FA, offset: 0x7C089, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5coderACSgSo7NSCoderC_tcfcTo', symObjAddr: 0x2EC4, symBinAddr: 0xDB04, symSize: 0x28 }
+  - { offsetInCU: 0x114F, offset: 0x7C0DE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5frameACSo6CGRectV_tcfcTo', symObjAddr: 0x3944, symBinAddr: 0xE584, symSize: 0x20 }
+  - { offsetInCU: 0x1182, offset: 0x7C111, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvgTo', symObjAddr: 0x3964, symBinAddr: 0xE5A4, symSize: 0x10 }
+  - { offsetInCU: 0x11A2, offset: 0x7C131, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvgTo', symObjAddr: 0x3964, symBinAddr: 0xE5A4, symSize: 0x10 }
+  - { offsetInCU: 0x11DA, offset: 0x7C169, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvsTo', symObjAddr: 0x3974, symBinAddr: 0xE5B4, symSize: 0x34 }
+  - { offsetInCU: 0x1248, offset: 0x7C1D7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13readyListenerAA0cE0_pSgvgTo', symObjAddr: 0x3A28, symBinAddr: 0xE668, symSize: 0x20 }
+  - { offsetInCU: 0x12A2, offset: 0x7C231, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13readyListenerAA0cE0_pSgvsTo', symObjAddr: 0x3A48, symBinAddr: 0xE688, symSize: 0x34 }
+  - { offsetInCU: 0x1302, offset: 0x7C291, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11setListeneryyAA0cE0_pSgFTo', symObjAddr: 0x3AAC, symBinAddr: 0xE6EC, symSize: 0x34 }
+  - { offsetInCU: 0x1446, offset: 0x7C3D5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC14layoutSubviewsyyFTo', symObjAddr: 0x3DF8, symBinAddr: 0xEA38, symSize: 0x28 }
+  - { offsetInCU: 0x1479, offset: 0x7C408, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCfDTo', symObjAddr: 0x4124, symBinAddr: 0xED64, symSize: 0x24 }
+  - { offsetInCU: 0x14B4, offset: 0x7C443, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC21getBoundingClientRectyySo6UIViewC_SvtFZTo', symObjAddr: 0x4210, symBinAddr: 0xEE50, symSize: 0x34 }
+  - { offsetInCU: 0x14E7, offset: 0x7C476, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC14shared_context33_508084857CA7D194CA72FEB80DD78002LLs5Int64VvgZTf4d_n', symObjAddr: 0x4BAC, symBinAddr: 0xF7EC, symSize: 0x2A8 }
+  - { offsetInCU: 0x1664, offset: 0x7C5F3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC21getBoundingClientRectyySo6UIViewC_SvtFZTf4nnd_n', symObjAddr: 0x4F18, symBinAddr: 0xFB58, symSize: 0xA0 }
+  - { offsetInCU: 0x18E0, offset: 0x7C86F, size: 0x8, addend: 0x0, symName: '_$sIeg_IeyB_TR', symObjAddr: 0x1EB0, symBinAddr: 0xCAF0, symSize: 0x2C }
+  - { offsetInCU: 0x18F8, offset: 0x7C887, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_So8NSStringCABIeyByy_TR', symObjAddr: 0x2160, symBinAddr: 0xCDA0, symSize: 0x78 }
+  - { offsetInCU: 0x1910, offset: 0x7C89F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvpACTK', symObjAddr: 0x22C8, symBinAddr: 0xCF08, symSize: 0x94 }
+  - { offsetInCU: 0x1948, offset: 0x7C8D7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvpACTk', symObjAddr: 0x235C, symBinAddr: 0xCF9C, symSize: 0xB8 }
+  - { offsetInCU: 0x198A, offset: 0x7C919, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCytIegnnr_SSABIeggg_TR', symObjAddr: 0x2414, symBinAddr: 0xD054, symSize: 0x6C }
+  - { offsetInCU: 0x1A3A, offset: 0x7C9C9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCfETo', symObjAddr: 0x4148, symBinAddr: 0xED88, symSize: 0xC4 }
+  - { offsetInCU: 0x1A6A, offset: 0x7C9F9, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_SgWOy', symObjAddr: 0x4244, symBinAddr: 0xEE84, symSize: 0x10 }
+  - { offsetInCU: 0x1A7E, offset: 0x7CA0D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCMa', symObjAddr: 0x4254, symBinAddr: 0xEE94, symSize: 0x20 }
+  - { offsetInCU: 0x1A92, offset: 0x7CA21, size: 0x8, addend: 0x0, symName: '_$ss29getContiguousArrayStorageType3fors01_bcD0CyxGmxm_tlFSo18NSLayoutConstraintC_Tgm5', symObjAddr: 0x4274, symBinAddr: 0xEEB4, symSize: 0x64 }
+  - { offsetInCU: 0x1C99, offset: 0x7CC28, size: 0x8, addend: 0x0, symName: ___swift_instantiateConcreteTypeFromMangledName, symObjAddr: 0x4E54, symBinAddr: 0xFA94, symSize: 0x40 }
+  - { offsetInCU: 0x1CAD, offset: 0x7CC3C, size: 0x8, addend: 0x0, symName: '_$sypSgWOh', symObjAddr: 0x4E94, symBinAddr: 0xFAD4, symSize: 0x40 }
+  - { offsetInCU: 0x1CC1, offset: 0x7CC50, size: 0x8, addend: 0x0, symName: ___swift_project_boxed_opaque_existential_0, symObjAddr: 0x4ED4, symBinAddr: 0xFB14, symSize: 0x24 }
+  - { offsetInCU: 0x1CD5, offset: 0x7CC64, size: 0x8, addend: 0x0, symName: ___swift_destroy_boxed_opaque_existential_0, symObjAddr: 0x4EF8, symBinAddr: 0xFB38, symSize: 0x20 }
+  - { offsetInCU: 0x1CF4, offset: 0x7CC83, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSo19UIGestureRecognizerCIeyByy_SSADIeggg_TRTA', symObjAddr: 0x53E4, symBinAddr: 0x10024, symSize: 0x48 }
+  - { offsetInCU: 0x1D1D, offset: 0x7CCAC, size: 0x8, addend: 0x0, symName: _block_copy_helper, symObjAddr: 0x542C, symBinAddr: 0x1006C, symSize: 0x10 }
+  - { offsetInCU: 0x1D31, offset: 0x7CCC0, size: 0x8, addend: 0x0, symName: _block_destroy_helper, symObjAddr: 0x543C, symBinAddr: 0x1007C, symSize: 0x8 }
+  - { offsetInCU: 0x1D45, offset: 0x7CCD4, size: 0x8, addend: 0x0, symName: '_$sIeg_SgWOe', symObjAddr: 0x5444, symBinAddr: 0x10084, symSize: 0x10 }
+  - { offsetInCU: 0x1D64, offset: 0x7CCF3, size: 0x8, addend: 0x0, symName: '_$sIeyB_Ieg_TRTA', symObjAddr: 0x5454, symBinAddr: 0x10094, symSize: 0xC }
+  - { offsetInCU: 0x1D8D, offset: 0x7CD1C, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCytIegnnr_SSABIeggg_TRTA', symObjAddr: 0x5484, symBinAddr: 0x100C4, symSize: 0x8 }
+  - { offsetInCU: 0x1DAC, offset: 0x7CD3B, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_SSABytIegnnr_TRTA', symObjAddr: 0x548C, symBinAddr: 0x100CC, symSize: 0x30 }
+  - { offsetInCU: 0x1DD5, offset: 0x7CD64, size: 0x8, addend: 0x0, symName: '_$sypWOb', symObjAddr: 0x54BC, symBinAddr: 0x100FC, symSize: 0x10 }
+  - { offsetInCU: 0x1DE9, offset: 0x7CD78, size: 0x8, addend: 0x0, symName: '_$sypWOc', symObjAddr: 0x5504, symBinAddr: 0x10144, symSize: 0x3C }
+  - { offsetInCU: 0x206E, offset: 0x7CFFD, size: 0x8, addend: 0x0, symName: '_$sSD17dictionaryLiteralSDyxq_Gx_q_td_tcfCSS_ypTgm5Tf4g_n', symObjAddr: 0x4A94, symBinAddr: 0xF6D4, symSize: 0x118 }
+  - { offsetInCU: 0x2514, offset: 0x7D4A3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvg', symObjAddr: 0x2E0, symBinAddr: 0xAF20, symSize: 0x44 }
+  - { offsetInCU: 0x2547, offset: 0x7D4D6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvs', symObjAddr: 0x354, symBinAddr: 0xAF94, symSize: 0xEC }
+  - { offsetInCU: 0x2593, offset: 0x7D522, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvM', symObjAddr: 0x440, symBinAddr: 0xB080, symSize: 0x58 }
+  - { offsetInCU: 0x25B8, offset: 0x7D547, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvM.resume.0', symObjAddr: 0x498, symBinAddr: 0xB0D8, symSize: 0xE0 }
+  - { offsetInCU: 0x25F9, offset: 0x7D588, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8nativeGLs5Int64Vvg', symObjAddr: 0x5BC, symBinAddr: 0xB1FC, symSize: 0x44 }
+  - { offsetInCU: 0x2651, offset: 0x7D5E0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13nativeContexts5Int64Vvg', symObjAddr: 0x68C, symBinAddr: 0xB2CC, symSize: 0x44 }
+  - { offsetInCU: 0x27BF, offset: 0x7D74E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18drawingBufferWidthSivg', symObjAddr: 0x834, symBinAddr: 0xB474, symSize: 0xD0 }
+  - { offsetInCU: 0x28E4, offset: 0x7D873, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19drawingBufferHeightSivg', symObjAddr: 0x938, symBinAddr: 0xB578, symSize: 0xD0 }
+  - { offsetInCU: 0x2A2A, offset: 0x7D9B9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5widthSfvg', symObjAddr: 0xA28, symBinAddr: 0xB668, symSize: 0x24 }
+  - { offsetInCU: 0x2A72, offset: 0x7DA01, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6heightSfvg', symObjAddr: 0xA6C, symBinAddr: 0xB6AC, symSize: 0x24 }
+  - { offsetInCU: 0x2AA6, offset: 0x7DA35, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11initContextyySS_S4bs5Int32VS5btF', symObjAddr: 0xA90, symBinAddr: 0xB6D0, symSize: 0x24 }
+  - { offsetInCU: 0x2C34, offset: 0x7DBC3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17initWebGPUContextyys5Int64VF', symObjAddr: 0xB78, symBinAddr: 0xB7B8, symSize: 0x198 }
+  - { offsetInCU: 0x3027, offset: 0x7DFB6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC015initContextWithE10AttributesyySS_S4bs5Int32VS5btF', symObjAddr: 0xD40, symBinAddr: 0xB980, symSize: 0x888 }
+  - { offsetInCU: 0x382A, offset: 0x7E7B9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15create2DContextys5Int64VSb_S3bs5Int32VS5bAHtF', symObjAddr: 0x168C, symBinAddr: 0xC2CC, symSize: 0x258 }
+  - { offsetInCU: 0x3C5C, offset: 0x7EBEB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11forceLayoutyy12CoreGraphics7CGFloatV_AGtF', symObjAddr: 0x1994, symBinAddr: 0xC5D4, symSize: 0xC0 }
+  - { offsetInCU: 0x3CED, offset: 0x7EC7C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8snapshotySo7UIImageCSgSbF', symObjAddr: 0x1B0C, symBinAddr: 0xC74C, symSize: 0xE4 }
+  - { offsetInCU: 0x3E48, offset: 0x7EDD7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6renderSbyF', symObjAddr: 0x1C70, symBinAddr: 0xC8B0, symSize: 0x48 }
+  - { offsetInCU: 0x3ECE, offset: 0x7EE5D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13context2DTestyys5Int64VF', symObjAddr: 0x1D00, symBinAddr: 0xC940, symSize: 0x4C }
+  - { offsetInCU: 0x3FEF, offset: 0x7EF7E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC22context2DTestToDataURLySSs5Int64VF', symObjAddr: 0x1DB0, symBinAddr: 0xC9F0, symSize: 0x58 }
+  - { offsetInCU: 0x40E5, offset: 0x7F074, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvg', symObjAddr: 0x2108, symBinAddr: 0xCD48, symSize: 0x58 }
+  - { offsetInCU: 0x4131, offset: 0x7F0C0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvs', symObjAddr: 0x226C, symBinAddr: 0xCEAC, symSize: 0x5C }
+  - { offsetInCU: 0x415A, offset: 0x7F0E9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvM', symObjAddr: 0x2480, symBinAddr: 0xD0C0, symSize: 0x44 }
+  - { offsetInCU: 0x4180, offset: 0x7F10F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvM.resume.0', symObjAddr: 0x24C4, symBinAddr: 0xD104, symSize: 0x4 }
+  - { offsetInCU: 0x4242, offset: 0x7F1D1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5coderACSgSo7NSCoderC_tcfc', symObjAddr: 0x24C8, symBinAddr: 0xD108, symSize: 0x9FC }
+  - { offsetInCU: 0x4465, offset: 0x7F3F4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5frameACSo6CGRectV_tcfC', symObjAddr: 0x2EEC, symBinAddr: 0xDB2C, symSize: 0x50 }
+  - { offsetInCU: 0x448E, offset: 0x7F41D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5frameACSo6CGRectV_tcfc', symObjAddr: 0x2F3C, symBinAddr: 0xDB7C, symSize: 0xA08 }
+  - { offsetInCU: 0x46D2, offset: 0x7F661, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvW', symObjAddr: 0x39A8, symBinAddr: 0xE5E8, symSize: 0x80 }
+  - { offsetInCU: 0x47C8, offset: 0x7F757, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11setListeneryyAA0cE0_pSgF', symObjAddr: 0x3A7C, symBinAddr: 0xE6BC, symSize: 0x30 }
+  - { offsetInCU: 0x4866, offset: 0x7F7F5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6resize33_508084857CA7D194CA72FEB80DD78002LLyyF', symObjAddr: 0x3AE0, symBinAddr: 0xE720, symSize: 0x144 }
+  - { offsetInCU: 0x4A67, offset: 0x7F9F6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC14layoutSubviewsyyF', symObjAddr: 0x3C24, symBinAddr: 0xE864, symSize: 0x1D4 }
+  - { offsetInCU: 0x4CE4, offset: 0x7FC73, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCfD', symObjAddr: 0x3E20, symBinAddr: 0xEA60, symSize: 0x304 }
+  - { offsetInCU: 0x4D74, offset: 0x7FD03, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC21getBoundingClientRectyySo6UIViewC_SvtFZ', symObjAddr: 0x420C, symBinAddr: 0xEE4C, symSize: 0x4 }
+  - { offsetInCU: 0x4D9C, offset: 0x7FD2B, size: 0x8, addend: 0x0, symName: '_$ss22__RawDictionaryStorageC4findys10_HashTableV6BucketV6bucket_Sb5foundtxSHRzlFSS_Tg5', symObjAddr: 0x42D8, symBinAddr: 0xEF18, symSize: 0x64 }
+  - { offsetInCU: 0x4DF6, offset: 0x7FD85, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV7_insert2at3key5valueys10_HashTableV6BucketV_xnq_ntFSS_ypTg5', symObjAddr: 0x433C, symBinAddr: 0xEF7C, symSize: 0x6C }
+  - { offsetInCU: 0x4E76, offset: 0x7FE05, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV12mutatingFind_8isUniques10_HashTableV6BucketV6bucket_Sb5foundtx_SbtFSS_ypTg5', symObjAddr: 0x43A8, symBinAddr: 0xEFE8, symSize: 0xD8 }
+  - { offsetInCU: 0x4EB3, offset: 0x7FE42, size: 0x8, addend: 0x0, symName: '_$ss22__RawDictionaryStorageC4find_9hashValues10_HashTableV6BucketV6bucket_Sb5foundtx_SitSHRzlFSS_Tg5', symObjAddr: 0x4480, symBinAddr: 0xF0C0, symSize: 0xE0 }
+  - { offsetInCU: 0x4F2E, offset: 0x7FEBD, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV4copyyyFSS_ypTg5', symObjAddr: 0x4560, symBinAddr: 0xF1A0, symSize: 0x1F4 }
+  - { offsetInCU: 0x4FEA, offset: 0x7FF79, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV20_copyOrMoveAndResize8capacity12moveElementsySi_SbtFSS_ypTg5', symObjAddr: 0x4754, symBinAddr: 0xF394, symSize: 0x340 }
+  - { offsetInCU: 0x27, offset: 0x801E1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative7GLUtilsCfD', symObjAddr: 0x0, symBinAddr: 0x101E4, symSize: 0x10 }
+  - { offsetInCU: 0x62, offset: 0x8021C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative7GLUtilsCMa', symObjAddr: 0x10, symBinAddr: 0x101F4, symSize: 0x20 }
+  - { offsetInCU: 0x1AF, offset: 0x80369, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative7GLUtilsCfD', symObjAddr: 0x0, symBinAddr: 0x101E4, symSize: 0x10 }
+  - { offsetInCU: 0x65, offset: 0x803F8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8mPrograms6UInt32VvgTo', symObjAddr: 0x0, symBinAddr: 0x10214, symSize: 0x10 }
+  - { offsetInCU: 0x85, offset: 0x80418, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8mPrograms6UInt32VvgTo', symObjAddr: 0x0, symBinAddr: 0x10214, symSize: 0x10 }
+  - { offsetInCU: 0xBB, offset: 0x8044E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8mPrograms6UInt32VvsTo', symObjAddr: 0x10, symBinAddr: 0x10224, symSize: 0x10 }
+  - { offsetInCU: 0xDB, offset: 0x8046E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8mPrograms6UInt32VvsTo', symObjAddr: 0x10, symBinAddr: 0x10224, symSize: 0x10 }
+  - { offsetInCU: 0x114, offset: 0x804A7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3rbos6UInt32VvgTo', symObjAddr: 0x20, symBinAddr: 0x10234, symSize: 0x44 }
+  - { offsetInCU: 0x16C, offset: 0x804FF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3rbos6UInt32VvsTo', symObjAddr: 0x64, symBinAddr: 0x10278, symSize: 0x48 }
+  - { offsetInCU: 0x1C7, offset: 0x8055A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3fbos6UInt32VvgTo', symObjAddr: 0xAC, symBinAddr: 0x102C0, symSize: 0x44 }
+  - { offsetInCU: 0x21F, offset: 0x805B2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3fbos6UInt32VvsTo', symObjAddr: 0xF0, symBinAddr: 0x10304, symSize: 0x48 }
+  - { offsetInCU: 0x27A, offset: 0x8060D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC5widthSivgTo', symObjAddr: 0x138, symBinAddr: 0x1034C, symSize: 0x10 }
+  - { offsetInCU: 0x29A, offset: 0x8062D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC5widthSivgTo', symObjAddr: 0x138, symBinAddr: 0x1034C, symSize: 0x10 }
+  - { offsetInCU: 0x2D0, offset: 0x80663, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC5widthSivsTo', symObjAddr: 0x148, symBinAddr: 0x1035C, symSize: 0x10 }
+  - { offsetInCU: 0x2F0, offset: 0x80683, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC5widthSivsTo', symObjAddr: 0x148, symBinAddr: 0x1035C, symSize: 0x10 }
+  - { offsetInCU: 0x329, offset: 0x806BC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC6heightSivgTo', symObjAddr: 0x158, symBinAddr: 0x1036C, symSize: 0x10 }
+  - { offsetInCU: 0x349, offset: 0x806DC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC6heightSivgTo', symObjAddr: 0x158, symBinAddr: 0x1036C, symSize: 0x10 }
+  - { offsetInCU: 0x37F, offset: 0x80712, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC6heightSivsTo', symObjAddr: 0x168, symBinAddr: 0x1037C, symSize: 0x10 }
+  - { offsetInCU: 0x39F, offset: 0x80732, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC6heightSivsTo', symObjAddr: 0x168, symBinAddr: 0x1037C, symSize: 0x10 }
+  - { offsetInCU: 0x3D8, offset: 0x8076B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC2abs6UInt32VvgTo', symObjAddr: 0x178, symBinAddr: 0x1038C, symSize: 0x44 }
+  - { offsetInCU: 0x430, offset: 0x807C3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC2abs6UInt32VvsTo', symObjAddr: 0x1BC, symBinAddr: 0x103D0, symSize: 0x48 }
+  - { offsetInCU: 0x48B, offset: 0x8081E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3poss5Int32VvgTo', symObjAddr: 0x204, symBinAddr: 0x10418, symSize: 0x10 }
+  - { offsetInCU: 0x4AB, offset: 0x8083E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3poss5Int32VvgTo', symObjAddr: 0x204, symBinAddr: 0x10418, symSize: 0x10 }
+  - { offsetInCU: 0x4E1, offset: 0x80874, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3poss5Int32VvsTo', symObjAddr: 0x214, symBinAddr: 0x10428, symSize: 0x10 }
+  - { offsetInCU: 0x501, offset: 0x80894, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3poss5Int32VvsTo', symObjAddr: 0x214, symBinAddr: 0x10428, symSize: 0x10 }
+  - { offsetInCU: 0x53A, offset: 0x808CD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10samplerPoss5Int32VvgTo', symObjAddr: 0x224, symBinAddr: 0x10438, symSize: 0x10 }
+  - { offsetInCU: 0x55A, offset: 0x808ED, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10samplerPoss5Int32VvgTo', symObjAddr: 0x224, symBinAddr: 0x10438, symSize: 0x10 }
+  - { offsetInCU: 0x590, offset: 0x80923, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10samplerPoss5Int32VvsTo', symObjAddr: 0x234, symBinAddr: 0x10448, symSize: 0x10 }
+  - { offsetInCU: 0x5B0, offset: 0x80943, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10samplerPoss5Int32VvsTo', symObjAddr: 0x234, symBinAddr: 0x10448, symSize: 0x10 }
+  - { offsetInCU: 0x5E9, offset: 0x8097C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9vextexBufSaySfGvgTo', symObjAddr: 0x244, symBinAddr: 0x10458, symSize: 0x48 }
+  - { offsetInCU: 0x63F, offset: 0x809D2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9vextexBufSaySfGvsTo', symObjAddr: 0x28C, symBinAddr: 0x104A0, symSize: 0x40 }
+  - { offsetInCU: 0x682, offset: 0x80A15, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13SIZE_OF_FLOATSivgZTo', symObjAddr: 0x2CC, symBinAddr: 0x104E0, symSize: 0x8 }
+  - { offsetInCU: 0x69E, offset: 0x80A31, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13VERTEX_SHADERSSvgZTo', symObjAddr: 0x2D4, symBinAddr: 0x104E8, symSize: 0x2C }
+  - { offsetInCU: 0x6D0, offset: 0x80A63, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7surfaceSo9IOSurfaceCSgvgTo', symObjAddr: 0x300, symBinAddr: 0x10514, symSize: 0x10 }
+  - { offsetInCU: 0x6F0, offset: 0x80A83, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7surfaceSo9IOSurfaceCSgvgTo', symObjAddr: 0x300, symBinAddr: 0x10514, symSize: 0x10 }
+  - { offsetInCU: 0x728, offset: 0x80ABB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7surfaceSo9IOSurfaceCSgvsTo', symObjAddr: 0x310, symBinAddr: 0x10524, symSize: 0x34 }
+  - { offsetInCU: 0x781, offset: 0x80B14, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8pixelBufs9UnmanagedVySo11CVBufferRefaGSgvgTo', symObjAddr: 0x418, symBinAddr: 0x1062C, symSize: 0x10 }
+  - { offsetInCU: 0x7A1, offset: 0x80B34, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8pixelBufs9UnmanagedVySo11CVBufferRefaGSgvgTo', symObjAddr: 0x418, symBinAddr: 0x1062C, symSize: 0x10 }
+  - { offsetInCU: 0x7D7, offset: 0x80B6A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8pixelBufs9UnmanagedVySo11CVBufferRefaGSgvsTo', symObjAddr: 0x428, symBinAddr: 0x1063C, symSize: 0x10 }
+  - { offsetInCU: 0x7F7, offset: 0x80B8A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8pixelBufs9UnmanagedVySo11CVBufferRefaGSgvsTo', symObjAddr: 0x428, symBinAddr: 0x1063C, symSize: 0x10 }
+  - { offsetInCU: 0x846, offset: 0x80BD9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCACycfcTo', symObjAddr: 0x5BC, symBinAddr: 0x10790, symSize: 0x20 }
+  - { offsetInCU: 0x878, offset: 0x80C0B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7destroyyyFTo', symObjAddr: 0x720, symBinAddr: 0x108F4, symSize: 0x28 }
+  - { offsetInCU: 0x8D0, offset: 0x80C63, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10texImage2Dyys5Int32V_A4fA9NSCCanvasCAHSbtFTo', symObjAddr: 0x75C, symBinAddr: 0x10930, symSize: 0x88 }
+  - { offsetInCU: 0x934, offset: 0x80CC7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9drawFrame6buffer5width6height14internalFormat6format10flipYWebGLySo11CVBufferRefa_S2is5Int32VANSbtFTo', symObjAddr: 0x7E4, symBinAddr: 0x109B8, symSize: 0x7C }
+  - { offsetInCU: 0x9D6, offset: 0x80D69, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13createSurfaceyyFTo', symObjAddr: 0xC0C, symBinAddr: 0x10DE0, symSize: 0x28 }
+  - { offsetInCU: 0xAC0, offset: 0x80E53, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCMa', symObjAddr: 0x59C, symBinAddr: 0x10770, symSize: 0x20 }
+  - { offsetInCU: 0xB34, offset: 0x80EC7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCfETo', symObjAddr: 0xC64, symBinAddr: 0x10E38, symSize: 0x58 }
+  - { offsetInCU: 0x123B, offset: 0x815CE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCACycfC', symObjAddr: 0x438, symBinAddr: 0x1064C, symSize: 0x20 }
+  - { offsetInCU: 0x1255, offset: 0x815E8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCACycfc', symObjAddr: 0x458, symBinAddr: 0x1066C, symSize: 0x104 }
+  - { offsetInCU: 0x1287, offset: 0x8161A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7destroyyyF', symObjAddr: 0x5DC, symBinAddr: 0x107B0, symSize: 0x144 }
+  - { offsetInCU: 0x1442, offset: 0x817D5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10texImage2Dyys5Int32V_A4fA9NSCCanvasCAHSbtF', symObjAddr: 0x748, symBinAddr: 0x1091C, symSize: 0x14 }
+  - { offsetInCU: 0x14F3, offset: 0x81886, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13createSurfaceyyF', symObjAddr: 0x860, symBinAddr: 0x10A34, symSize: 0x3AC }
+  - { offsetInCU: 0x1863, offset: 0x81BF6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCfD', symObjAddr: 0xC34, symBinAddr: 0x10E08, symSize: 0x30 }
+  - { offsetInCU: 0x194E, offset: 0x81CE1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10texImage2Dyys5Int32V_A4fA9NSCCanvasCAHSbtFTf4ddnndnndn_n', symObjAddr: 0xCBC, symBinAddr: 0x10E90, symSize: 0x65C }
+  - { offsetInCU: 0x214C, offset: 0x824DF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9drawFrame6buffer5width6height14internalFormat6format10flipYWebGLySo11CVBufferRefa_S2is5Int32VANSbtFTf4nnnnndn_n', symObjAddr: 0x135C, symBinAddr: 0x11530, symSize: 0x6C8 }
+  - { offsetInCU: 0x10C, offset: 0x82E9F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC6target6actionAEypSg_10ObjectiveC8SelectorVSgtcfcTo', symObjAddr: 0xED4, symBinAddr: 0x12AA4, symSize: 0x68 }
+  - { offsetInCU: 0x19C, offset: 0x82F2F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerCfETo', symObjAddr: 0xF48, symBinAddr: 0x12B18, symSize: 0x10 }
+  - { offsetInCU: 0x1CB, offset: 0x82F5E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC6handleyySo19UIGestureRecognizerCFTo', symObjAddr: 0xF58, symBinAddr: 0x12B28, symSize: 0x4 }
+  - { offsetInCU: 0x368, offset: 0x830FB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerCACycfcTo', symObjAddr: 0x16DC, symBinAddr: 0x132AC, symSize: 0x2C }
+  - { offsetInCU: 0x5D4, offset: 0x83367, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerCfETo', symObjAddr: 0x1744, symBinAddr: 0x13314, symSize: 0x68 }
+  - { offsetInCU: 0x603, offset: 0x83396, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerCMa', symObjAddr: 0x17AC, symBinAddr: 0x1337C, symSize: 0x20 }
+  - { offsetInCU: 0x617, offset: 0x833AA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerCMa', symObjAddr: 0x17CC, symBinAddr: 0x1339C, symSize: 0x20 }
+  - { offsetInCU: 0x62B, offset: 0x833BE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwCP', symObjAddr: 0x17EC, symBinAddr: 0x133BC, symSize: 0x30 }
+  - { offsetInCU: 0x63F, offset: 0x833D2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwxx', symObjAddr: 0x181C, symBinAddr: 0x133EC, symSize: 0x8 }
+  - { offsetInCU: 0x653, offset: 0x833E6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwcp', symObjAddr: 0x1824, symBinAddr: 0x133F4, symSize: 0x3C }
+  - { offsetInCU: 0x667, offset: 0x833FA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwca', symObjAddr: 0x1860, symBinAddr: 0x13430, symSize: 0x50 }
+  - { offsetInCU: 0x67B, offset: 0x8340E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwta', symObjAddr: 0x18BC, symBinAddr: 0x13480, symSize: 0x40 }
+  - { offsetInCU: 0x68F, offset: 0x83422, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwet', symObjAddr: 0x18FC, symBinAddr: 0x134C0, symSize: 0x48 }
+  - { offsetInCU: 0x6A3, offset: 0x83436, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwst', symObjAddr: 0x1944, symBinAddr: 0x13508, symSize: 0x40 }
+  - { offsetInCU: 0x6B7, offset: 0x8344A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVMa', symObjAddr: 0x1984, symBinAddr: 0x13548, symSize: 0x10 }
+  - { offsetInCU: 0x6CB, offset: 0x8345E, size: 0x8, addend: 0x0, symName: '_$sypSgWOc', symObjAddr: 0x1994, symBinAddr: 0x13558, symSize: 0x48 }
+  - { offsetInCU: 0x6DF, offset: 0x83472, size: 0x8, addend: 0x0, symName: '_$sSo7UITouchCSo8NSObjectCSH10ObjectiveCWl', symObjAddr: 0x1AA0, symBinAddr: 0x135A0, symSize: 0x58 }
+  - { offsetInCU: 0x6F3, offset: 0x83486, size: 0x8, addend: 0x0, symName: '_$sSh8IteratorV8_VariantOyx__GSHRzlWOe', symObjAddr: 0x1AF8, symBinAddr: 0x135F8, symSize: 0x8 }
+  - { offsetInCU: 0x761, offset: 0x834F4, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_SgWOe', symObjAddr: 0x1DEC, symBinAddr: 0x138EC, symSize: 0x10 }
+  - { offsetInCU: 0xCBB, offset: 0x83A4E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC12touchesBegan_4withyShySo7UITouchCG_So7UIEventCtF', symObjAddr: 0x0, symBinAddr: 0x11BF8, symSize: 0x540 }
+  - { offsetInCU: 0xF57, offset: 0x83CEA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC12touchesMoved_4withyShySo7UITouchCG_So7UIEventCtF', symObjAddr: 0x54C, symBinAddr: 0x12144, symSize: 0xE0 }
+  - { offsetInCU: 0xFD6, offset: 0x83D69, size: 0x8, addend: 0x0, symName: '_$sSa6remove2atxSi_tF12CanvasNative15NSCTouchHandlerC7PointerV_Tg5', symObjAddr: 0x6F0, symBinAddr: 0x122D4, symSize: 0x9C }
+  - { offsetInCU: 0x1069, offset: 0x83DFC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC6target6actionAEypSg_10ObjectiveC8SelectorVSgtcfc', symObjAddr: 0xDCC, symBinAddr: 0x1299C, symSize: 0x108 }
+  - { offsetInCU: 0x11B3, offset: 0x83F46, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC6onMove33_044DDF836BDB3B89B481C6F58BB6EF6BLLyySo19UIGestureRecognizerC_ShySo7UITouchCGSgtF', symObjAddr: 0x12D0, symBinAddr: 0x12EA0, symSize: 0x40C }
+  - { offsetInCU: 0x18C9, offset: 0x8465C, size: 0x8, addend: 0x0, symName: '_$ss12_ArrayBufferV20_consumeAndCreateNewAByxGyF12CanvasNative15NSCTouchHandlerC7PointerV_Tg5', symObjAddr: 0x1B00, symBinAddr: 0x13600, symSize: 0x14 }
+  - { offsetInCU: 0x1968, offset: 0x846FB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC6canvasAcA9NSCCanvasC_tcfcTf4gn_n', symObjAddr: 0x1B14, symBinAddr: 0x13614, symSize: 0x1E4 }
+  - { offsetInCU: 0x27, offset: 0x848D8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC14FAILED_TO_LOADSSvgZTo', symObjAddr: 0x0, symBinAddr: 0x138FC, symSize: 0x2C }
+  - { offsetInCU: 0x4B, offset: 0x848FC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queueSo012OS_dispatch_E0CvpZ', symObjAddr: 0x2D8, symBinAddr: 0x115E888, symSize: 0x0 }
+  - { offsetInCU: 0x65, offset: 0x84916, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC14FAILED_TO_LOADSSvgZTo', symObjAddr: 0x0, symBinAddr: 0x138FC, symSize: 0x2C }
+  - { offsetInCU: 0x98, offset: 0x84949, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queueSo012OS_dispatch_E0CvgZTo', symObjAddr: 0x178, symBinAddr: 0x13A74, symSize: 0x40 }
+  - { offsetInCU: 0x104, offset: 0x849B5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCACycfcTo', symObjAddr: 0x228, symBinAddr: 0x13B24, symSize: 0x3C }
+  - { offsetInCU: 0x156, offset: 0x84A07, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queue_WZ', symObjAddr: 0x2C, symBinAddr: 0x13928, symSize: 0x10C }
+  - { offsetInCU: 0x181, offset: 0x84A32, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCMa', symObjAddr: 0x208, symBinAddr: 0x13B04, symSize: 0x20 }
+  - { offsetInCU: 0x195, offset: 0x84A46, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCfETo', symObjAddr: 0x294, symBinAddr: 0x13B90, symSize: 0x4 }
+  - { offsetInCU: 0x1C0, offset: 0x84A71, size: 0x8, addend: 0x0, symName: '_$sSo17OS_dispatch_queueCMa', symObjAddr: 0x298, symBinAddr: 0x13B94, symSize: 0x3C }
+  - { offsetInCU: 0x348, offset: 0x84BF9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queueSo012OS_dispatch_E0CvgZ', symObjAddr: 0x138, symBinAddr: 0x13A34, symSize: 0x40 }
+  - { offsetInCU: 0x388, offset: 0x84C39, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCACycfC', symObjAddr: 0x1B8, symBinAddr: 0x13AB4, symSize: 0x20 }
+  - { offsetInCU: 0x39C, offset: 0x84C4D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCACycfc', symObjAddr: 0x1D8, symBinAddr: 0x13AD4, symSize: 0x30 }
+  - { offsetInCU: 0x3D8, offset: 0x84C89, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCfD', symObjAddr: 0x264, symBinAddr: 0x13B60, symSize: 0x30 }
+  - { offsetInCU: 0x2B, offset: 0x84CD7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC18createTextureCacheSo017CVOpenGLESTextureF3RefaSgyFZ', symObjAddr: 0x0, symBinAddr: 0x13BD0, symSize: 0xA4 }
+  - { offsetInCU: 0x66, offset: 0x84D12, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC18createTextureCacheSo017CVOpenGLESTextureF3RefaSgyFZTo', symObjAddr: 0xA4, symBinAddr: 0x13C74, symSize: 0xA4 }
+  - { offsetInCU: 0xF9, offset: 0x84DA5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11createImageySo11CVBufferRefaSgSo022CVOpenGLESTextureCacheG0a_AFSo012CFDictionaryG0aSgs6UInt32Vs5Int32VA2p2NSitFZTo', symObjAddr: 0x1D8, symBinAddr: 0x13DA8, symSize: 0x110 }
+  - { offsetInCU: 0x1A2, offset: 0x84E4E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11setupRenderAA9NSCRenderCyFZTo', symObjAddr: 0x30C, symBinAddr: 0x13EDC, symSize: 0x28 }
+  - { offsetInCU: 0x222, offset: 0x84ECE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC9drawFrameyySo8AVPlayerC_So0F15ItemVideoOutputCSo6CGSizeVAA9NSCRenderCs5Int32VANSbtFZTo', symObjAddr: 0x338, symBinAddr: 0x13F08, symSize: 0xA0 }
+  - { offsetInCU: 0x29B, offset: 0x84F47, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11writeToFileyySo6NSDataC_SStKFZTo', symObjAddr: 0x4D0, symBinAddr: 0x140A0, symSize: 0x15C }
+  - { offsetInCU: 0x330, offset: 0x84FDC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCACycfcTo', symObjAddr: 0x67C, symBinAddr: 0x1424C, symSize: 0x3C }
+  - { offsetInCU: 0x381, offset: 0x8502D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC9drawFrameyySo8AVPlayerC_So0F15ItemVideoOutputCSo6CGSizeVAA9NSCRenderCs5Int32VANSbtFZTf4nnnnnndd_n', symObjAddr: 0x6E8, symBinAddr: 0x142B8, symSize: 0x160 }
+  - { offsetInCU: 0x4DF, offset: 0x8518B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC7getFile33_F00B23A4165DD6ABFCD23C8811C7DF43LLyS2SKFZTf4nd_g', symObjAddr: 0x848, symBinAddr: 0x14418, symSize: 0x2E4 }
+  - { offsetInCU: 0x5AE, offset: 0x8525A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCMa', symObjAddr: 0xB2C, symBinAddr: 0x146FC, symSize: 0x20 }
+  - { offsetInCU: 0x5C2, offset: 0x8526E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOAEs5ErrorAAWl', symObjAddr: 0xB4C, symBinAddr: 0x1471C, symSize: 0x44 }
+  - { offsetInCU: 0x5D6, offset: 0x85282, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwCP', symObjAddr: 0xB90, symBinAddr: 0x14760, symSize: 0x2C }
+  - { offsetInCU: 0x5EA, offset: 0x85296, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwxx', symObjAddr: 0xBBC, symBinAddr: 0x1478C, symSize: 0x8 }
+  - { offsetInCU: 0x5FE, offset: 0x852AA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwca', symObjAddr: 0xBC4, symBinAddr: 0x14794, symSize: 0x40 }
+  - { offsetInCU: 0x612, offset: 0x852BE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwta', symObjAddr: 0xC10, symBinAddr: 0x147D4, symSize: 0x30 }
+  - { offsetInCU: 0x626, offset: 0x852D2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwet', symObjAddr: 0xC40, symBinAddr: 0x14804, symSize: 0x48 }
+  - { offsetInCU: 0x63A, offset: 0x852E6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwst', symObjAddr: 0xC88, symBinAddr: 0x1484C, symSize: 0x3C }
+  - { offsetInCU: 0x64E, offset: 0x852FA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwug', symObjAddr: 0xCC4, symBinAddr: 0x14888, symSize: 0x8 }
+  - { offsetInCU: 0x662, offset: 0x8530E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwup', symObjAddr: 0xCCC, symBinAddr: 0x14890, symSize: 0x4 }
+  - { offsetInCU: 0x676, offset: 0x85322, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwui', symObjAddr: 0xCD0, symBinAddr: 0x14894, symSize: 0x4 }
+  - { offsetInCU: 0x68A, offset: 0x85336, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOMa', symObjAddr: 0xCD4, symBinAddr: 0x14898, symSize: 0x10 }
+  - { offsetInCU: 0x712, offset: 0x853BE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP7_domainSSvgTW', symObjAddr: 0x3D8, symBinAddr: 0x13FA8, symSize: 0x4 }
+  - { offsetInCU: 0x72E, offset: 0x853DA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP5_codeSivgTW', symObjAddr: 0x3DC, symBinAddr: 0x13FAC, symSize: 0x4 }
+  - { offsetInCU: 0x74A, offset: 0x853F6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP9_userInfoyXlSgvgTW', symObjAddr: 0x3E0, symBinAddr: 0x13FB0, symSize: 0x4 }
+  - { offsetInCU: 0x766, offset: 0x85412, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP19_getEmbeddedNSErroryXlSgyFTW', symObjAddr: 0x3E4, symBinAddr: 0x13FB4, symSize: 0x4 }
+  - { offsetInCU: 0xA14, offset: 0x856C0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC18createTextureCacheSo017CVOpenGLESTextureF3RefaSgyFZ', symObjAddr: 0x0, symBinAddr: 0x13BD0, symSize: 0xA4 }
+  - { offsetInCU: 0xAAA, offset: 0x85756, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11createImageySo11CVBufferRefaSgSo022CVOpenGLESTextureCacheG0a_AFSo012CFDictionaryG0aSgs6UInt32Vs5Int32VA2p2NSitFZ', symObjAddr: 0x148, symBinAddr: 0x13D18, symSize: 0x90 }
+  - { offsetInCU: 0xC31, offset: 0x858DD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11setupRenderAA9NSCRenderCyFZ', symObjAddr: 0x2E8, symBinAddr: 0x13EB8, symSize: 0x24 }
+  - { offsetInCU: 0xC7B, offset: 0x85927, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC9drawFrameyySo8AVPlayerC_So0F15ItemVideoOutputCSo6CGSizeVAA9NSCRenderCs5Int32VANSbtFZ', symObjAddr: 0x334, symBinAddr: 0x13F04, symSize: 0x4 }
+  - { offsetInCU: 0xC9D, offset: 0x85949, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11writeToFileyySo6NSDataC_SStKFZ', symObjAddr: 0x3E8, symBinAddr: 0x13FB8, symSize: 0xE8 }
+  - { offsetInCU: 0xD4D, offset: 0x859F9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCACycfC', symObjAddr: 0x62C, symBinAddr: 0x141FC, symSize: 0x20 }
+  - { offsetInCU: 0xD61, offset: 0x85A0D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCACycfc', symObjAddr: 0x64C, symBinAddr: 0x1421C, symSize: 0x30 }
+  - { offsetInCU: 0xD97, offset: 0x85A43, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCfD', symObjAddr: 0x6B8, symBinAddr: 0x14288, symSize: 0x30 }
+  - { offsetInCU: 0x27, offset: 0x85B5C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x0, symBinAddr: 0x148AC, symSize: 0x4 }
+  - { offsetInCU: 0x71, offset: 0x85BA6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZTo', symObjAddr: 0x4, symBinAddr: 0x148B0, symSize: 0x70 }
+  - { offsetInCU: 0xF6, offset: 0x85C2B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS2ftFZTo', symObjAddr: 0x78, symBinAddr: 0x14924, symSize: 0x50 }
+  - { offsetInCU: 0x191, offset: 0x85CC6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS4ftFZTo', symObjAddr: 0xCC, symBinAddr: 0x14978, symSize: 0x68 }
+  - { offsetInCU: 0x254, offset: 0x85D89, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS8ftFZTo', symObjAddr: 0x138, symBinAddr: 0x149E4, symSize: 0x98 }
+  - { offsetInCU: 0x323, offset: 0x85E58, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCACycfcTo', symObjAddr: 0x220, symBinAddr: 0x14ACC, symSize: 0x3C }
+  - { offsetInCU: 0x375, offset: 0x85EAA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCMa', symObjAddr: 0x28C, symBinAddr: 0x14B38, symSize: 0x20 }
+  - { offsetInCU: 0x4E5, offset: 0x8601A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x0, symBinAddr: 0x148AC, symSize: 0x4 }
+  - { offsetInCU: 0x51D, offset: 0x86052, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x0, symBinAddr: 0x148AC, symSize: 0x4 }
+  - { offsetInCU: 0x588, offset: 0x860BD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS2ftFZ', symObjAddr: 0x74, symBinAddr: 0x14920, symSize: 0x4 }
+  - { offsetInCU: 0x5C8, offset: 0x860FD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS2ftFZ', symObjAddr: 0x74, symBinAddr: 0x14920, symSize: 0x4 }
+  - { offsetInCU: 0x62A, offset: 0x8615F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS4ftFZ', symObjAddr: 0xC8, symBinAddr: 0x14974, symSize: 0x4 }
+  - { offsetInCU: 0x67C, offset: 0x861B1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS4ftFZ', symObjAddr: 0xC8, symBinAddr: 0x14974, symSize: 0x4 }
+  - { offsetInCU: 0x6F1, offset: 0x86226, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS8ftFZ', symObjAddr: 0x134, symBinAddr: 0x149E0, symSize: 0x4 }
+  - { offsetInCU: 0x767, offset: 0x8629C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS8ftFZ', symObjAddr: 0x134, symBinAddr: 0x149E0, symSize: 0x4 }
+  - { offsetInCU: 0x805, offset: 0x8633A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCACycfC', symObjAddr: 0x1D0, symBinAddr: 0x14A7C, symSize: 0x20 }
+  - { offsetInCU: 0x819, offset: 0x8634E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCACycfc', symObjAddr: 0x1F0, symBinAddr: 0x14A9C, symSize: 0x30 }
+  - { offsetInCU: 0x84F, offset: 0x86384, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCfD', symObjAddr: 0x25C, symBinAddr: 0x14B08, symSize: 0x30 }
+  - { offsetInCU: 0x27, offset: 0x863CE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC10texImage2Dyys5Int64V_s5Int32VA4HSpys5UInt8VGSuSo6CGSizeVSbtFZ', symObjAddr: 0x0, symBinAddr: 0x14B58, symSize: 0x14 }
+  - { offsetInCU: 0xA9, offset: 0x86450, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC10texImage2Dyys5Int64V_s5Int32VA4HSpys5UInt8VGSuSo6CGSizeVSbtFZTo', symObjAddr: 0x14, symBinAddr: 0x14B6C, symSize: 0x38 }
+  - { offsetInCU: 0x1A2, offset: 0x86549, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC13texSubImage2Dyys5Int64V_s5Int32VA5HSpys5UInt8VGSuSo6CGSizeVSbtFZTo', symObjAddr: 0x68, symBinAddr: 0x14BC0, symSize: 0x40 }
+  - { offsetInCU: 0x284, offset: 0x8662B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCACycfcTo', symObjAddr: 0x118, symBinAddr: 0x14C70, symSize: 0x3C }
+  - { offsetInCU: 0x2D6, offset: 0x8667D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCMa', symObjAddr: 0xF8, symBinAddr: 0x14C50, symSize: 0x20 }
+  - { offsetInCU: 0x480, offset: 0x86827, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC10texImage2Dyys5Int64V_s5Int32VA4HSpys5UInt8VGSuSo6CGSizeVSbtFZ', symObjAddr: 0x0, symBinAddr: 0x14B58, symSize: 0x14 }
+  - { offsetInCU: 0x5C4, offset: 0x8696B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC13texSubImage2Dyys5Int64V_s5Int32VA5HSpys5UInt8VGSuSo6CGSizeVSbtFZ', symObjAddr: 0x4C, symBinAddr: 0x14BA4, symSize: 0x1C }
+  - { offsetInCU: 0x6FA, offset: 0x86AA1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCACycfC', symObjAddr: 0xA8, symBinAddr: 0x14C00, symSize: 0x20 }
+  - { offsetInCU: 0x70E, offset: 0x86AB5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCACycfc', symObjAddr: 0xC8, symBinAddr: 0x14C20, symSize: 0x30 }
+  - { offsetInCU: 0x744, offset: 0x86AEB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCfD', symObjAddr: 0x154, symBinAddr: 0x14CAC, symSize: 0x30 }
+  - { offsetInCU: 0x61, offset: 0x86B6F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7isDirtySbvgTo', symObjAddr: 0x4, symBinAddr: 0x14CE0, symSize: 0x10 }
+  - { offsetInCU: 0x81, offset: 0x86B8F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7isDirtySbvgTo', symObjAddr: 0x4, symBinAddr: 0x14CE0, symSize: 0x10 }
+  - { offsetInCU: 0xB7, offset: 0x86BC5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7isDirtySbvsTo', symObjAddr: 0x14, symBinAddr: 0x14CF0, symSize: 0x10 }
+  - { offsetInCU: 0xD7, offset: 0x86BE5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7isDirtySbvsTo', symObjAddr: 0x14, symBinAddr: 0x14CF0, symSize: 0x10 }
+  - { offsetInCU: 0x110, offset: 0x86C1E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC6canvasAA9NSCCanvasCSgvgTo', symObjAddr: 0x24, symBinAddr: 0x14D00, symSize: 0x48 }
+  - { offsetInCU: 0x168, offset: 0x86C76, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC6canvasAA9NSCCanvasCSgvsTo', symObjAddr: 0xB4, symBinAddr: 0x14D90, symSize: 0x50 }
+  - { offsetInCU: 0x1C3, offset: 0x86CD1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC3fbos6UInt32VvgTo', symObjAddr: 0x104, symBinAddr: 0x14DE0, symSize: 0x10 }
+  - { offsetInCU: 0x1E3, offset: 0x86CF1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC3fbos6UInt32VvgTo', symObjAddr: 0x104, symBinAddr: 0x14DE0, symSize: 0x10 }
+  - { offsetInCU: 0x219, offset: 0x86D27, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC3fbos6UInt32VvsTo', symObjAddr: 0x114, symBinAddr: 0x14DF0, symSize: 0x10 }
+  - { offsetInCU: 0x239, offset: 0x86D47, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC3fbos6UInt32VvsTo', symObjAddr: 0x114, symBinAddr: 0x14DF0, symSize: 0x10 }
+  - { offsetInCU: 0x272, offset: 0x86D80, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCACycfcTo', symObjAddr: 0x1B0, symBinAddr: 0x14E8C, symSize: 0x78 }
+  - { offsetInCU: 0x2C8, offset: 0x86DD6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frameACSo6CGRectV_tcfcTo', symObjAddr: 0x2D4, symBinAddr: 0x14FB0, symSize: 0xB0 }
+  - { offsetInCU: 0x32A, offset: 0x86E38, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5coderACSgSo7NSCoderC_tcfcTo', symObjAddr: 0x43C, symBinAddr: 0x15118, symSize: 0x28 }
+  - { offsetInCU: 0x35C, offset: 0x86E6A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC12bindDrawableyyFTo', symObjAddr: 0x4E0, symBinAddr: 0x15140, symSize: 0xA0 }
+  - { offsetInCU: 0x3DD, offset: 0x86EEB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC14deleteDrawableyyFTo', symObjAddr: 0x5BC, symBinAddr: 0x151E0, symSize: 0x60 }
+  - { offsetInCU: 0x44D, offset: 0x86F5B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7glkView_6drawInySo0C0C_So6CGRectVtFTo', symObjAddr: 0x620, symBinAddr: 0x15244, symSize: 0x4C }
+  - { offsetInCU: 0x4BF, offset: 0x86FCD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frame7contextACSo6CGRectV_So11EAGLContextCtcfcTo', symObjAddr: 0x70C, symBinAddr: 0x15330, symSize: 0x34 }
+  - { offsetInCU: 0x533, offset: 0x87041, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCMa', symObjAddr: 0x190, symBinAddr: 0x14E6C, symSize: 0x20 }
+  - { offsetInCU: 0x55D, offset: 0x8706B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCfETo', symObjAddr: 0x74C, symBinAddr: 0x15370, symSize: 0x10 }
+  - { offsetInCU: 0x65B, offset: 0x87169, size: 0x8, addend: 0x0, symName: '_$sSo7GLKViewC12CanvasNativeE16snapshotWithDatayy10Foundation0F0VFTo', symObjAddr: 0xA08, symBinAddr: 0x1562C, symSize: 0x74 }
+  - { offsetInCU: 0x699, offset: 0x871A7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC7isDirtySbvgTo', symObjAddr: 0xA7C, symBinAddr: 0x156A0, symSize: 0x10 }
+  - { offsetInCU: 0x6B9, offset: 0x871C7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC7isDirtySbvgTo', symObjAddr: 0xA7C, symBinAddr: 0x156A0, symSize: 0x10 }
+  - { offsetInCU: 0x6EF, offset: 0x871FD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC7isDirtySbvsTo', symObjAddr: 0xA8C, symBinAddr: 0x156B0, symSize: 0x10 }
+  - { offsetInCU: 0x70F, offset: 0x8721D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC7isDirtySbvsTo', symObjAddr: 0xA8C, symBinAddr: 0x156B0, symSize: 0x10 }
+  - { offsetInCU: 0x748, offset: 0x87256, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC8rendererAA9NSCCanvasCSgvgTo', symObjAddr: 0xA9C, symBinAddr: 0x156C0, symSize: 0x20 }
+  - { offsetInCU: 0x7A0, offset: 0x872AE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC8rendererAA9NSCCanvasCSgvsTo', symObjAddr: 0xABC, symBinAddr: 0x156E0, symSize: 0x14 }
+  - { offsetInCU: 0x7FB, offset: 0x87309, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvgTo', symObjAddr: 0xAD0, symBinAddr: 0x156F4, symSize: 0x44 }
+  - { offsetInCU: 0x853, offset: 0x87361, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvsTo', symObjAddr: 0xB58, symBinAddr: 0x1577C, symSize: 0x48 }
+  - { offsetInCU: 0x8E8, offset: 0x873F6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCACycfcTo', symObjAddr: 0xCBC, symBinAddr: 0x158E0, symSize: 0x78 }
+  - { offsetInCU: 0x93E, offset: 0x8744C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5frameACSo6CGRectV_tcfcTo', symObjAddr: 0xE34, symBinAddr: 0x15A58, symSize: 0xB0 }
+  - { offsetInCU: 0x9A0, offset: 0x874AE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5coderACSgSo7NSCoderC_tcfcTo', symObjAddr: 0xF90, symBinAddr: 0x15BB4, symSize: 0x28 }
+  - { offsetInCU: 0x9D2, offset: 0x874E0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC11deviceScaleSfyFTo', symObjAddr: 0xFB8, symBinAddr: 0x15BDC, symSize: 0xB8 }
+  - { offsetInCU: 0xA53, offset: 0x87561, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC4drawyySo6CGRectVFTo', symObjAddr: 0x1074, symBinAddr: 0x15C94, symSize: 0x28 }
+  - { offsetInCU: 0xAB1, offset: 0x875BF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCfETo', symObjAddr: 0x10D8, symBinAddr: 0x15CF8, symSize: 0x10 }
+  - { offsetInCU: 0xC63, offset: 0x87771, size: 0x8, addend: 0x0, symName: '_$ss22_ContiguousArrayBufferV19_uninitializedCount15minimumCapacityAByxGSi_SitcfC12CanvasNative15NSCTouchHandlerC7PointerV_Tgm5', symObjAddr: 0x130C, symBinAddr: 0x15E78, symSize: 0x80 }
+  - { offsetInCU: 0xCE6, offset: 0x877F4, size: 0x8, addend: 0x0, symName: '_$ss22_ContiguousArrayBufferV19_uninitializedCount15minimumCapacityAByxGSi_SitcfCs5UInt8V_Tgm5', symObjAddr: 0x140C, symBinAddr: 0x15EF8, symSize: 0x6C }
+  - { offsetInCU: 0xD6A, offset: 0x87878, size: 0x8, addend: 0x0, symName: '_$s10Foundation4DataV15_RepresentationOWOy', symObjAddr: 0x1630, symBinAddr: 0x1611C, symSize: 0x44 }
+  - { offsetInCU: 0xD7E, offset: 0x8788C, size: 0x8, addend: 0x0, symName: '_$s10Foundation4DataV15_RepresentationOWOe', symObjAddr: 0x1674, symBinAddr: 0x16160, symSize: 0x44 }
+  - { offsetInCU: 0xD92, offset: 0x878A0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCMa', symObjAddr: 0x16B8, symBinAddr: 0x161A4, symSize: 0x20 }
+  - { offsetInCU: 0xE6C, offset: 0x8797A, size: 0x8, addend: 0x0, symName: '_$sSaySayxGqd__c7ElementQyd__RszSTRd__lufCs5UInt8V_10Foundation4DataVTgm5Tf4g_n', symObjAddr: 0x14FC, symBinAddr: 0x15FE8, symSize: 0x124 }
+  - { offsetInCU: 0x112B, offset: 0x87C39, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC6canvasAA9NSCCanvasCSgvg', symObjAddr: 0x6C, symBinAddr: 0x14D48, symSize: 0x48 }
+  - { offsetInCU: 0x11A8, offset: 0x87CB6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCACycfc', symObjAddr: 0x124, symBinAddr: 0x14E00, symSize: 0x6C }
+  - { offsetInCU: 0x11EF, offset: 0x87CFD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frameACSo6CGRectV_tcfc', symObjAddr: 0x228, symBinAddr: 0x14F04, symSize: 0xAC }
+  - { offsetInCU: 0x1253, offset: 0x87D61, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5coderACSgSo7NSCoderC_tcfc', symObjAddr: 0x384, symBinAddr: 0x15060, symSize: 0xB8 }
+  - { offsetInCU: 0x12DE, offset: 0x87DEC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7glkView_6drawInySo0C0C_So6CGRectVtF', symObjAddr: 0x61C, symBinAddr: 0x15240, symSize: 0x4 }
+  - { offsetInCU: 0x12FF, offset: 0x87E0D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frame7contextACSo6CGRectV_So11EAGLContextCtcfC', symObjAddr: 0x66C, symBinAddr: 0x15290, symSize: 0x74 }
+  - { offsetInCU: 0x1313, offset: 0x87E21, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frame7contextACSo6CGRectV_So11EAGLContextCtcfc', symObjAddr: 0x6E0, symBinAddr: 0x15304, symSize: 0x2C }
+  - { offsetInCU: 0x142C, offset: 0x87F3A, size: 0x8, addend: 0x0, symName: '_$sSo7GLKViewC12CanvasNativeE16snapshotWithDatayy10Foundation0F0VF', symObjAddr: 0x75C, symBinAddr: 0x15380, symSize: 0x2AC }
+  - { offsetInCU: 0x17D6, offset: 0x882E4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvg', symObjAddr: 0xB14, symBinAddr: 0x15738, symSize: 0x44 }
+  - { offsetInCU: 0x1815, offset: 0x88323, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvs', symObjAddr: 0xBA0, symBinAddr: 0x157C4, symSize: 0x48 }
+  - { offsetInCU: 0x183A, offset: 0x88348, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvM', symObjAddr: 0xBE8, symBinAddr: 0x1580C, symSize: 0x44 }
+  - { offsetInCU: 0x185F, offset: 0x8836D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvM.resume.0', symObjAddr: 0xC2C, symBinAddr: 0x15850, symSize: 0x4 }
+  - { offsetInCU: 0x1886, offset: 0x88394, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCACycfC', symObjAddr: 0xC30, symBinAddr: 0x15854, symSize: 0x20 }
+  - { offsetInCU: 0x189A, offset: 0x883A8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCACycfc', symObjAddr: 0xC50, symBinAddr: 0x15874, symSize: 0x6C }
+  - { offsetInCU: 0x18E1, offset: 0x883EF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5frameACSo6CGRectV_tcfc', symObjAddr: 0xD88, symBinAddr: 0x159AC, symSize: 0xAC }
+  - { offsetInCU: 0x1940, offset: 0x8844E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5coderACSgSo7NSCoderC_tcfc', symObjAddr: 0xEE4, symBinAddr: 0x15B08, symSize: 0xAC }
+  - { offsetInCU: 0x19DE, offset: 0x884EC, size: 0x8, addend: 0x0, symName: '_$ss12_ArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtF12CanvasNative15NSCTouchHandlerC7PointerV_Tg5', symObjAddr: 0x10E8, symBinAddr: 0x15D08, symSize: 0xBC }
+  - { offsetInCU: 0x1AC0, offset: 0x885CE, size: 0x8, addend: 0x0, symName: '_$ss12_ArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtFs5UInt8V_Tg5', symObjAddr: 0x1258, symBinAddr: 0x15DC4, symSize: 0xB4 }
+  - { offsetInCU: 0x1BCC, offset: 0x886DA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7glkView_6drawInySo0C0C_So6CGRectVtFTf4ddn_n', symObjAddr: 0x1478, symBinAddr: 0x15F64, symSize: 0x84 }
+  - { offsetInCU: 0x1CC5, offset: 0x887D3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC4drawyySo6CGRectVFTf4dn_n', symObjAddr: 0x16D8, symBinAddr: 0x161C4, symSize: 0x360 }
+  - { offsetInCU: 0x4F, offset: 0x88C11, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC5queue33_7ED578B0ED4B2B6F6887A622A7B49AA3LLSo012OS_dispatch_E0CvpZ', symObjAddr: 0x980, symBinAddr: 0x115E9D0, symSize: 0x0 }
+  - { offsetInCU: 0x5D, offset: 0x88C1F, size: 0x8, addend: 0x0, symName: '_$sIegh_IeyBh_TR', symObjAddr: 0x0, symBinAddr: 0x16710, symSize: 0x2C }
+  - { offsetInCU: 0x75, offset: 0x88C37, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC5queue33_7ED578B0ED4B2B6F6887A622A7B49AA3LL_WZ', symObjAddr: 0x2C, symBinAddr: 0x1673C, symSize: 0x10C }
+  - { offsetInCU: 0xBC, offset: 0x88C7E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF4SyncySbs5Int64V_So7UIImageCtFZTo', symObjAddr: 0x13C, symBinAddr: 0x1684C, symSize: 0x44 }
+  - { offsetInCU: 0x132, offset: 0x88CF4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZTo', symObjAddr: 0x3E4, symBinAddr: 0x16AF4, symSize: 0x80 }
+  - { offsetInCU: 0x191, offset: 0x88D53, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCACycfcTo', symObjAddr: 0x4B4, symBinAddr: 0x16BC4, symSize: 0x3C }
+  - { offsetInCU: 0x1E2, offset: 0x88DA4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZTf4nnnd_n', symObjAddr: 0x524, symBinAddr: 0x16C34, symSize: 0x214 }
+  - { offsetInCU: 0x261, offset: 0x88E23, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCfETo', symObjAddr: 0x520, symBinAddr: 0x16C30, symSize: 0x4 }
+  - { offsetInCU: 0x29D, offset: 0x88E5F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCMa', symObjAddr: 0x738, symBinAddr: 0x16E48, symSize: 0x20 }
+  - { offsetInCU: 0x2BC, offset: 0x88E7E, size: 0x8, addend: 0x0, symName: '_$s10ObjectiveC8ObjCBoolVIeyBy_SbIegy_TRTA', symObjAddr: 0x77C, symBinAddr: 0x16E8C, symSize: 0x14 }
+  - { offsetInCU: 0x2E5, offset: 0x88EA7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_TA', symObjAddr: 0x7BC, symBinAddr: 0x16ECC, symSize: 0xC }
+  - { offsetInCU: 0x2F9, offset: 0x88EBB, size: 0x8, addend: 0x0, symName: _block_copy_helper, symObjAddr: 0x7C8, symBinAddr: 0x16ED8, symSize: 0x10 }
+  - { offsetInCU: 0x30D, offset: 0x88ECF, size: 0x8, addend: 0x0, symName: _block_destroy_helper, symObjAddr: 0x7D8, symBinAddr: 0x16EE8, symSize: 0x8 }
+  - { offsetInCU: 0x321, offset: 0x88EE3, size: 0x8, addend: 0x0, symName: '_$sSay8Dispatch0A13WorkItemFlagsVGMa', symObjAddr: 0x860, symBinAddr: 0x16F30, symSize: 0x54 }
+  - { offsetInCU: 0x335, offset: 0x88EF7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_yyScMYccfU0_TA', symObjAddr: 0x8F0, symBinAddr: 0x16F84, symSize: 0x24 }
+  - { offsetInCU: 0x369, offset: 0x88F2B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_yyScMYccfU_TA', symObjAddr: 0x938, symBinAddr: 0x16FCC, symSize: 0x24 }
+  - { offsetInCU: 0x4FE, offset: 0x890C0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF4SyncySbs5Int64V_So7UIImageCtFZ', symObjAddr: 0x138, symBinAddr: 0x16848, symSize: 0x4 }
+  - { offsetInCU: 0x52C, offset: 0x890EE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF4SyncySbs5Int64V_So7UIImageCtFZ', symObjAddr: 0x138, symBinAddr: 0x16848, symSize: 0x4 }
+  - { offsetInCU: 0x58B, offset: 0x8914D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZ', symObjAddr: 0x180, symBinAddr: 0x16890, symSize: 0x4 }
+  - { offsetInCU: 0x59F, offset: 0x89161, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_', symObjAddr: 0x184, symBinAddr: 0x16894, symSize: 0x260 }
+  - { offsetInCU: 0x678, offset: 0x8923A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCACycfC', symObjAddr: 0x464, symBinAddr: 0x16B74, symSize: 0x20 }
+  - { offsetInCU: 0x68C, offset: 0x8924E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCACycfc', symObjAddr: 0x484, symBinAddr: 0x16B94, symSize: 0x30 }
+  - { offsetInCU: 0x6C2, offset: 0x89284, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCfD', symObjAddr: 0x4F0, symBinAddr: 0x16C00, symSize: 0x30 }
+  - { offsetInCU: 0x27, offset: 0x8932A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfC', symObjAddr: 0x0, symBinAddr: 0x17004, symSize: 0x20 }
+  - { offsetInCU: 0x77, offset: 0x8937A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfcTo', symObjAddr: 0x70, symBinAddr: 0x17074, symSize: 0x3C }
+  - { offsetInCU: 0xC9, offset: 0x893CC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCMa', symObjAddr: 0x50, symBinAddr: 0x17054, symSize: 0x20 }
+  - { offsetInCU: 0x214, offset: 0x89517, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfC', symObjAddr: 0x0, symBinAddr: 0x17004, symSize: 0x20 }
+  - { offsetInCU: 0x228, offset: 0x8952B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfc', symObjAddr: 0x20, symBinAddr: 0x17024, symSize: 0x30 }
+  - { offsetInCU: 0x264, offset: 0x89567, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCfD', symObjAddr: 0xAC, symBinAddr: 0x170B0, symSize: 0x30 }
+  - { offsetInCU: 0x26, offset: 0x895B0, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_frombytes_vartime, symObjAddr: 0x0, symBinAddr: 0x32FE28, symSize: 0x265C }
+  - { offsetInCU: 0x40, offset: 0x895CA, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_k25519Precomp, symObjAddr: 0x9DE0, symBinAddr: 0xA29170, symSize: 0x0 }
+  - { offsetInCU: 0x92, offset: 0x8961C, size: 0x8, addend: 0x0, symName: _d, symObjAddr: 0xFDE0, symBinAddr: 0xA2F170, symSize: 0x0 }
+  - { offsetInCU: 0xF6, offset: 0x89680, size: 0x8, addend: 0x0, symName: _sqrtm1, symObjAddr: 0xFE08, symBinAddr: 0xA2F198, symSize: 0x0 }
+  - { offsetInCU: 0x10C, offset: 0x89696, size: 0x8, addend: 0x0, symName: _d2, symObjAddr: 0x10210, symBinAddr: 0xA2F5A0, symSize: 0x0 }
+  - { offsetInCU: 0x123, offset: 0x896AD, size: 0x8, addend: 0x0, symName: _Bi, symObjAddr: 0xFE50, symBinAddr: 0xA2F1E0, symSize: 0x0 }
+  - { offsetInCU: 0x9C2, offset: 0x89F4C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_frombytes_vartime, symObjAddr: 0x0, symBinAddr: 0x32FE28, symSize: 0x265C }
+  - { offsetInCU: 0x45CD, offset: 0x8DB57, size: 0x8, addend: 0x0, symName: _fe_frombytes, symObjAddr: 0x265C, symBinAddr: 0x332484, symSize: 0x134 }
+  - { offsetInCU: 0x46F3, offset: 0x8DC7D, size: 0x8, addend: 0x0, symName: _fe_mul_impl, symObjAddr: 0x9918, symBinAddr: 0x339740, symSize: 0x21C }
+  - { offsetInCU: 0x4922, offset: 0x8DEAC, size: 0x8, addend: 0x0, symName: _fe_tobytes, symObjAddr: 0x4FDC, symBinAddr: 0x334E04, symSize: 0x1B8 }
+  - { offsetInCU: 0x530F, offset: 0x8E899, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_scalarmult_base, symObjAddr: 0x2790, symBinAddr: 0x3325B8, symSize: 0x5BC }
+  - { offsetInCU: 0x5F72, offset: 0x8F4FC, size: 0x8, addend: 0x0, symName: _table_select, symObjAddr: 0x2D4C, symBinAddr: 0x332B74, symSize: 0x7F8 }
+  - { offsetInCU: 0x642A, offset: 0x8F9B4, size: 0x8, addend: 0x0, symName: _ge_madd, symObjAddr: 0x3544, symBinAddr: 0x33336C, symSize: 0x208 }
+  - { offsetInCU: 0x69F8, offset: 0x8FF82, size: 0x8, addend: 0x0, symName: _ge_p2_dbl, symObjAddr: 0x374C, symBinAddr: 0x333574, symSize: 0x7B0 }
+  - { offsetInCU: 0x77D8, offset: 0x90D62, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_sc_reduce, symObjAddr: 0x3EFC, symBinAddr: 0x333D24, symSize: 0x634 }
+  - { offsetInCU: 0x8199, offset: 0x91723, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_scalar_mult_generic_masked, symObjAddr: 0x4530, symBinAddr: 0x334358, symSize: 0xAAC }
+  - { offsetInCU: 0x956A, offset: 0x92AF4, size: 0x8, addend: 0x0, symName: _fe_loose_invert, symObjAddr: 0x5298, symBinAddr: 0x3350C0, symSize: 0x23F8 }
+  - { offsetInCU: 0xCABB, offset: 0x96045, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_public_from_private_generic_masked, symObjAddr: 0x5194, symBinAddr: 0x334FBC, symSize: 0x104 }
+  - { offsetInCU: 0xCD03, offset: 0x9628D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_invert, symObjAddr: 0x7690, symBinAddr: 0x3374B8, symSize: 0x30 }
+  - { offsetInCU: 0xCDF4, offset: 0x9637E, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_isnegative, symObjAddr: 0x76C0, symBinAddr: 0x3374E8, symSize: 0x58 }
+  - { offsetInCU: 0xCE69, offset: 0x963F3, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_mul_ttt, symObjAddr: 0x7718, symBinAddr: 0x337540, symSize: 0x4 }
+  - { offsetInCU: 0xCEB1, offset: 0x9643B, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_mul_ttt, symObjAddr: 0x7718, symBinAddr: 0x337540, symSize: 0x4 }
+  - { offsetInCU: 0xCEE0, offset: 0x9646A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_mul_ttt, symObjAddr: 0x7718, symBinAddr: 0x337540, symSize: 0x4 }
+  - { offsetInCU: 0xCF04, offset: 0x9648E, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_neg, symObjAddr: 0x771C, symBinAddr: 0x337544, symSize: 0x8C }
+  - { offsetInCU: 0xD039, offset: 0x965C3, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_tobytes, symObjAddr: 0x77A8, symBinAddr: 0x3375D0, symSize: 0x4 }
+  - { offsetInCU: 0xD072, offset: 0x965FC, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_tobytes, symObjAddr: 0x77A8, symBinAddr: 0x3375D0, symSize: 0x4 }
+  - { offsetInCU: 0xD30B, offset: 0x96895, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_double_scalarmult_vartime, symObjAddr: 0x77AC, symBinAddr: 0x3375D4, symSize: 0x1598 }
+  - { offsetInCU: 0x10654, offset: 0x99BDE, size: 0x8, addend: 0x0, symName: _x25519_ge_add, symObjAddr: 0x9B34, symBinAddr: 0x33995C, symSize: 0x218 }
+  - { offsetInCU: 0x10C86, offset: 0x9A210, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_sc_mask, symObjAddr: 0x8D44, symBinAddr: 0x338B6C, symSize: 0x20 }
+  - { offsetInCU: 0x11123, offset: 0x9A6AD, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_sc_muladd, symObjAddr: 0x8D64, symBinAddr: 0x338B8C, symSize: 0xBB4 }
+  - { offsetInCU: 0x26, offset: 0x9B490, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_from_montgomery_in_place, symObjAddr: 0x0, symBinAddr: 0x339B74, symSize: 0x1F4 }
+  - { offsetInCU: 0x1D2, offset: 0x9B63C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_from_montgomery_in_place, symObjAddr: 0x0, symBinAddr: 0x339B74, symSize: 0x1F4 }
+  - { offsetInCU: 0x26, offset: 0x9B8D7, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_neg_inv_mod_r_u64, symObjAddr: 0x0, symBinAddr: 0x339D68, symSize: 0x3C }
+  - { offsetInCU: 0x34, offset: 0x9B8E5, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_neg_inv_mod_r_u64, symObjAddr: 0x0, symBinAddr: 0x339D68, symSize: 0x3C }
+  - { offsetInCU: 0x26, offset: 0x9B9F5, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_little_endian_bytes_from_scalar, symObjAddr: 0x0, symBinAddr: 0x339DA4, symSize: 0x98 }
+  - { offsetInCU: 0x34, offset: 0x9BA03, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_little_endian_bytes_from_scalar, symObjAddr: 0x0, symBinAddr: 0x339DA4, symSize: 0x98 }
+  - { offsetInCU: 0x86, offset: 0x9BB66, size: 0x8, addend: 0x0, symName: _Q_N0, symObjAddr: 0x1100, symBinAddr: 0xA2F650, symSize: 0x0 }
+  - { offsetInCU: 0xB8, offset: 0x9BB98, size: 0x8, addend: 0x0, symName: _Q, symObjAddr: 0x1090, symBinAddr: 0xA2F5E0, symSize: 0x0 }
+  - { offsetInCU: 0xDA, offset: 0x9BBBA, size: 0x8, addend: 0x0, symName: _N, symObjAddr: 0x10C0, symBinAddr: 0xA2F610, symSize: 0x0 }
+  - { offsetInCU: 0xF0, offset: 0x9BBD0, size: 0x8, addend: 0x0, symName: _N_N0, symObjAddr: 0x10F0, symBinAddr: 0xA2F640, symSize: 0x0 }
+  - { offsetInCU: 0x3B7, offset: 0x9BE97, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_elem_mul_mont, symObjAddr: 0x100, symBinAddr: 0x339E3C, symSize: 0x18 }
+  - { offsetInCU: 0x3FB, offset: 0x9BEDB, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_elem_mul_mont, symObjAddr: 0x100, symBinAddr: 0x339E3C, symSize: 0x18 }
+  - { offsetInCU: 0x594, offset: 0x9C074, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_scalar_mul_mont, symObjAddr: 0x1F8, symBinAddr: 0x339E54, symSize: 0x18 }
+  - { offsetInCU: 0x63F, offset: 0x9C11F, size: 0x8, addend: 0x0, symName: _nistz384_point_double, symObjAddr: 0x290, symBinAddr: 0x339E6C, symSize: 0x320 }
+  - { offsetInCU: 0x1199, offset: 0x9CC79, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_point_add, symObjAddr: 0x5B0, symBinAddr: 0x33A18C, symSize: 0xAC }
+  - { offsetInCU: 0x148F, offset: 0x9CF6F, size: 0x8, addend: 0x0, symName: _nistz384_point_add, symObjAddr: 0x65C, symBinAddr: 0x33A238, symSize: 0x500 }
+  - { offsetInCU: 0x268C, offset: 0x9E16C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_point_mul, symObjAddr: 0xB5C, symBinAddr: 0x33A738, symSize: 0x2C8 }
+  - { offsetInCU: 0x2CDB, offset: 0x9E7BB, size: 0x8, addend: 0x0, symName: _p384_point_select_w5, symObjAddr: 0xE24, symBinAddr: 0x33AA00, symSize: 0xF4 }
+  - { offsetInCU: 0x2EED, offset: 0x9E9CD, size: 0x8, addend: 0x0, symName: _add_precomputed_w5, symObjAddr: 0xF18, symBinAddr: 0x33AAF4, symSize: 0x168 }
+  - { offsetInCU: 0x26, offset: 0x9ED32, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_zero, symObjAddr: 0x0, symBinAddr: 0x33AC5C, symSize: 0x38 }
+  - { offsetInCU: 0xFA, offset: 0x9EE06, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_zero, symObjAddr: 0x0, symBinAddr: 0x33AC5C, symSize: 0x38 }
+  - { offsetInCU: 0x12C, offset: 0x9EE38, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_zero, symObjAddr: 0x0, symBinAddr: 0x33AC5C, symSize: 0x38 }
+  - { offsetInCU: 0x199, offset: 0x9EEA5, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_equal, symObjAddr: 0x38, symBinAddr: 0x33AC94, symSize: 0x3C }
+  - { offsetInCU: 0x1F3, offset: 0x9EEFF, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_equal, symObjAddr: 0x38, symBinAddr: 0x33AC94, symSize: 0x3C }
+  - { offsetInCU: 0x31B, offset: 0x9F027, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_equal_limb, symObjAddr: 0x74, symBinAddr: 0x33ACD0, symSize: 0x5C }
+  - { offsetInCU: 0x517, offset: 0x9F223, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_even, symObjAddr: 0xD0, symBinAddr: 0x33AD2C, symSize: 0x1C }
+  - { offsetInCU: 0x636, offset: 0x9F342, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_less_than, symObjAddr: 0xEC, symBinAddr: 0x33AD48, symSize: 0x54 }
+  - { offsetInCU: 0x6D9, offset: 0x9F3E5, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_less_than_limb, symObjAddr: 0x140, symBinAddr: 0x33AD9C, symSize: 0x4C }
+  - { offsetInCU: 0x8A7, offset: 0x9F5B3, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_reduce_once, symObjAddr: 0x18C, symBinAddr: 0x33ADE8, symSize: 0xA8 }
+  - { offsetInCU: 0x90B, offset: 0x9F617, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_reduce_once, symObjAddr: 0x18C, symBinAddr: 0x33ADE8, symSize: 0xA8 }
+  - { offsetInCU: 0xBAA, offset: 0x9F8B6, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_add_mod, symObjAddr: 0x234, symBinAddr: 0x33AE90, symSize: 0x110 }
+  - { offsetInCU: 0xC4C, offset: 0x9F958, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_add_mod, symObjAddr: 0x234, symBinAddr: 0x33AE90, symSize: 0x110 }
+  - { offsetInCU: 0xEDE, offset: 0x9FBEA, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_sub_mod, symObjAddr: 0x344, symBinAddr: 0x33AFA0, symSize: 0xB0 }
+  - { offsetInCU: 0xF5E, offset: 0x9FC6A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_sub_mod, symObjAddr: 0x344, symBinAddr: 0x33AFA0, symSize: 0xB0 }
+  - { offsetInCU: 0x10E1, offset: 0x9FDED, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_shl_mod, symObjAddr: 0x3F4, symBinAddr: 0x33B050, symSize: 0x178 }
+  - { offsetInCU: 0x13AB, offset: 0xA00B7, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_select_512_32, symObjAddr: 0x56C, symBinAddr: 0x33B1C8, symSize: 0x1F4 }
+  - { offsetInCU: 0x1500, offset: 0xA020C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_window5_split_window, symObjAddr: 0x760, symBinAddr: 0x33B3BC, symSize: 0x18 }
+  - { offsetInCU: 0x1567, offset: 0xA0273, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_window5_unsplit_window, symObjAddr: 0x778, symBinAddr: 0x33B3D4, symSize: 0xC }
+  - { offsetInCU: 0x15A0, offset: 0xA02AC, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMB_shr, symObjAddr: 0x784, symBinAddr: 0x33B3E0, symSize: 0x8 }
+  - { offsetInCU: 0x1624, offset: 0xA0330, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_limbs_mul_add_limb, symObjAddr: 0x78C, symBinAddr: 0x33B3E8, symSize: 0x3C }
+  - { offsetInCU: 0x26, offset: 0xA04E3, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_CRYPTO_memcmp, symObjAddr: 0x0, symBinAddr: 0x33B424, symSize: 0x170 }
+  - { offsetInCU: 0x34, offset: 0xA04F1, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_CRYPTO_memcmp, symObjAddr: 0x0, symBinAddr: 0x33B424, symSize: 0x170 }
+  - { offsetInCU: 0x34, offset: 0xA05F7, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_OPENSSL_armcap_P, symObjAddr: 0x374, symBinAddr: 0x1165D10, symSize: 0x0 }
+  - { offsetInCU: 0x26, offset: 0xA0639, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul, symObjAddr: 0x0, symBinAddr: 0x33B594, symSize: 0x388 }
+  - { offsetInCU: 0x76, offset: 0xA0689, size: 0x8, addend: 0x0, symName: _ecp_nistz256_precomputed, symObjAddr: 0x1000, symBinAddr: 0xA30000, symSize: 0x0 }
+  - { offsetInCU: 0xFA, offset: 0xA070D, size: 0x8, addend: 0x0, symName: _ONE, symObjAddr: 0x26000, symBinAddr: 0xA55000, symSize: 0x0 }
+  - { offsetInCU: 0x35B, offset: 0xA096E, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul, symObjAddr: 0x0, symBinAddr: 0x33B594, symSize: 0x388 }
+  - { offsetInCU: 0xC66, offset: 0xA1279, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul_base, symObjAddr: 0x388, symBinAddr: 0x33B91C, symSize: 0x204 }
+  - { offsetInCU: 0x1171, offset: 0xA1784, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul_base_vartime, symObjAddr: 0x58C, symBinAddr: 0x33BB20, symSize: 0x1BC }
+  - { offsetInCU: 0x10, offset: 0xA1B59, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_set_encrypt_key, symObjAddr: 0x0, symBinAddr: 0x33BCE0, symSize: 0x1A0 }
+  - { offsetInCU: 0x50, offset: 0xA1B99, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_set_encrypt_key, symObjAddr: 0x0, symBinAddr: 0x33BCE0, symSize: 0x1A0 }
+  - { offsetInCU: 0x5E, offset: 0xA1BA7, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_encrypt, symObjAddr: 0x1A0, symBinAddr: 0x33BE80, symSize: 0x60 }
+  - { offsetInCU: 0x81, offset: 0xA1BCA, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_ctr32_encrypt_blocks, symObjAddr: 0x200, symBinAddr: 0x33BEE0, symSize: 0x288 }
+  - { offsetInCU: 0x10, offset: 0xA1BBB, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_init_clmul, symObjAddr: 0x0, symBinAddr: 0x33C170, symSize: 0x130 }
+  - { offsetInCU: 0x48, offset: 0xA1BF3, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_init_clmul, symObjAddr: 0x0, symBinAddr: 0x33C170, symSize: 0x130 }
+  - { offsetInCU: 0x5F, offset: 0xA1C0A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_gmult_clmul, symObjAddr: 0x130, symBinAddr: 0x33C2A0, symSize: 0x70 }
+  - { offsetInCU: 0x75, offset: 0xA1C20, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_ghash_clmul, symObjAddr: 0x1A0, symBinAddr: 0x33C310, symSize: 0x160 }
+  - { offsetInCU: 0x7A, offset: 0xA1C25, size: 0x8, addend: 0x0, symName: gcm_ghash_v8_4x, symObjAddr: 0x300, symBinAddr: 0x33C470, symSize: 0x378 }
+  - { offsetInCU: 0x10, offset: 0xA1C33, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ChaCha20_ctr32, symObjAddr: 0x0, symBinAddr: 0x33C800, symSize: 0x3A0 }
+  - { offsetInCU: 0x48, offset: 0xA1C6B, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ChaCha20_ctr32, symObjAddr: 0x0, symBinAddr: 0x33C800, symSize: 0x3A0 }
+  - { offsetInCU: 0x4C, offset: 0xA1C6F, size: 0x8, addend: 0x0, symName: ChaCha20_neon, symObjAddr: 0x3A0, symBinAddr: 0x33CBA0, symSize: 0x6C0 }
+  - { offsetInCU: 0x66, offset: 0xA1C89, size: 0x8, addend: 0x0, symName: ChaCha20_512_neon, symObjAddr: 0xA60, symBinAddr: 0x33D260, symSize: 0x1138 }
+  - { offsetInCU: 0x50, offset: 0xA1CD5, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_chacha20_poly1305_seal, symObjAddr: 0x140, symBinAddr: 0x33E500, symSize: 0x1180 }
+  - { offsetInCU: 0x66, offset: 0xA1CEB, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_chacha20_poly1305_open, symObjAddr: 0x12C0, symBinAddr: 0x33F680, symSize: 0x1410 }
+  - { offsetInCU: 0x10, offset: 0xA1CE1, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_mul_mont, symObjAddr: 0x0, symBinAddr: 0x340AA0, symSize: 0x240 }
+  - { offsetInCU: 0x45, offset: 0xA1D16, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_mul_mont, symObjAddr: 0x0, symBinAddr: 0x340AA0, symSize: 0x240 }
+  - { offsetInCU: 0x4D, offset: 0xA1D1E, size: 0x8, addend: 0x0, symName: __bn_sqr8x_mont, symObjAddr: 0x240, symBinAddr: 0x340CE0, symSize: 0x9E0 }
+  - { offsetInCU: 0x63, offset: 0xA1D34, size: 0x8, addend: 0x0, symName: __bn_mul4x_mont, symObjAddr: 0xC20, symBinAddr: 0x3416C0, symSize: 0x650 }
+  - { offsetInCU: 0x10, offset: 0xA1D43, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_mul_mont, symObjAddr: 0x0, symBinAddr: 0x341D20, symSize: 0x40 }
+  - { offsetInCU: 0x47, offset: 0xA1D7A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_mul_mont, symObjAddr: 0x0, symBinAddr: 0x341D20, symSize: 0x40 }
+  - { offsetInCU: 0x5D, offset: 0xA1D90, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_sqr_mont, symObjAddr: 0x40, symBinAddr: 0x341D60, symSize: 0x40 }
+  - { offsetInCU: 0x76, offset: 0xA1DA9, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ecp_nistz256_neg, symObjAddr: 0x80, symBinAddr: 0x341DA0, symSize: 0x40 }
+  - { offsetInCU: 0x81, offset: 0xA1DB4, size: 0x8, addend: 0x0, symName: __ecp_nistz256_mul_mont, symObjAddr: 0xC0, symBinAddr: 0x341DE0, symSize: 0x1E0 }
+  - { offsetInCU: 0x97, offset: 0xA1DCA, size: 0x8, addend: 0x0, symName: __ecp_nistz256_sqr_mont, symObjAddr: 0x2A0, symBinAddr: 0x341FC0, symSize: 0x170 }
+  - { offsetInCU: 0xAB, offset: 0xA1DDE, size: 0x8, addend: 0x0, symName: __ecp_nistz256_add_to, symObjAddr: 0x410, symBinAddr: 0x342130, symSize: 0x50 }
+  - { offsetInCU: 0xC3, offset: 0xA1DF6, size: 0x8, addend: 0x0, symName: __ecp_nistz256_sub_from, symObjAddr: 0x460, symBinAddr: 0x342180, symSize: 0x50 }
+  - { offsetInCU: 0xD9, offset: 0xA1E0C, size: 0x8, addend: 0x0, symName: __ecp_nistz256_sub_morf, symObjAddr: 0x4B0, symBinAddr: 0x3421D0, symSize: 0x50 }
+  - { offsetInCU: 0xEF, offset: 0xA1E22, size: 0x8, addend: 0x0, symName: __ecp_nistz256_div_by_2, symObjAddr: 0x500, symBinAddr: 0x342220, symSize: 0x60 }
+  - { offsetInCU: 0x111, offset: 0xA1E44, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_double, symObjAddr: 0x560, symBinAddr: 0x342280, symSize: 0x1E0 }
+  - { offsetInCU: 0x124, offset: 0xA1E57, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_add, symObjAddr: 0x740, symBinAddr: 0x342460, symSize: 0x360 }
+  - { offsetInCU: 0x141, offset: 0xA1E74, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_add_affine, symObjAddr: 0xAA0, symBinAddr: 0x3427C0, symSize: 0x2D0 }
+  - { offsetInCU: 0x156, offset: 0xA1E89, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_scalar_mul_mont, symObjAddr: 0xD70, symBinAddr: 0x342A90, symSize: 0x2B0 }
+  - { offsetInCU: 0x170, offset: 0xA1EA3, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_scalar_sqr_rep_mont, symObjAddr: 0x1020, symBinAddr: 0x342D40, symSize: 0x250 }
+  - { offsetInCU: 0x184, offset: 0xA1EB7, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ecp_nistz256_select_w5, symObjAddr: 0x1270, symBinAddr: 0x342F90, symSize: 0x60 }
+  - { offsetInCU: 0x19A, offset: 0xA1ECD, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ecp_nistz256_select_w7, symObjAddr: 0x12D0, symBinAddr: 0x342FF0, symSize: 0x44 }
+  - { offsetInCU: 0x10, offset: 0xA1EC3, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_gcm_enc_kernel, symObjAddr: 0x0, symBinAddr: 0x343040, symSize: 0xB90 }
+  - { offsetInCU: 0x4C, offset: 0xA1EFF, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_gcm_enc_kernel, symObjAddr: 0x0, symBinAddr: 0x343040, symSize: 0xB90 }
+  - { offsetInCU: 0x62, offset: 0xA1F15, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_gcm_dec_kernel, symObjAddr: 0xB90, symBinAddr: 0x343BD0, symSize: 0xB98 }
+  - { offsetInCU: 0x10, offset: 0xA1F0F, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha512_block_data_order, symObjAddr: 0x0, symBinAddr: 0x344780, symSize: 0xE40 }
+  - { offsetInCU: 0x51, offset: 0xA1F50, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha512_block_data_order, symObjAddr: 0x0, symBinAddr: 0x344780, symSize: 0xE40 }
+  - { offsetInCU: 0x51, offset: 0xA1F50, size: 0x8, addend: 0x0, symName: sha512_block_armv8, symObjAddr: 0xE40, symBinAddr: 0x3455C0, symSize: 0x7E0 }
+  - { offsetInCU: 0x10, offset: 0xA1F5B, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha256_block_data_order, symObjAddr: 0x0, symBinAddr: 0x345DC0, symSize: 0xE40 }
+  - { offsetInCU: 0x51, offset: 0xA1F9C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha256_block_data_order, symObjAddr: 0x0, symBinAddr: 0x345DC0, symSize: 0xE40 }
+  - { offsetInCU: 0x51, offset: 0xA1F9C, size: 0x8, addend: 0x0, symName: sha256_block_armv8, symObjAddr: 0xE40, symBinAddr: 0x346C00, symSize: 0x1F0 }
 ...
diff --git a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/CanvasNative b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/CanvasNative
index 6d66cfdc1..0eb0379c4 100755
Binary files a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/CanvasNative and b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/CanvasNative differ
diff --git a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/Headers/canvas_native.h b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/Headers/canvas_native.h
index b299e05f8..bdf2fa39e 100644
--- a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/Headers/canvas_native.h
+++ b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/Headers/canvas_native.h
@@ -8,6 +8,38 @@
 #include <stdint.h>
 #include <stdlib.h>
 
+typedef enum CanvasAddressMode {
+  /**
+   * Clamp the value to the edge of the texture
+   *
+   * -0.25 -> 0.0
+   * 1.25  -> 1.0
+   */
+  CanvasAddressModeClampToEdge = 0,
+  /**
+   * Repeat the texture in a tiling fashion
+   *
+   * -0.25 -> 0.75
+   * 1.25 -> 0.25
+   */
+  CanvasAddressModeRepeat = 1,
+  /**
+   * Repeat the texture, mirroring it every repeat
+   *
+   * -0.25 -> 0.25
+   * 1.25 -> 0.75
+   */
+  CanvasAddressModeMirrorRepeat = 2,
+  /**
+   * Clamp the value to the border of the texture
+   * Requires feature [`Features::ADDRESS_MODE_CLAMP_TO_BORDER`]
+   *
+   * -0.25 -> border
+   * 1.25 -> border
+   */
+  CanvasAddressModeClampToBorder = 3,
+} CanvasAddressMode;
+
 /**
  * ASTC block dimensions
  */
@@ -188,6 +220,12 @@ typedef enum CanvasBlendOperation {
   CanvasBlendOperationMax = 4,
 } CanvasBlendOperation;
 
+typedef enum CanvasBufferBindingType {
+  CanvasBufferBindingTypeUniform,
+  CanvasBufferBindingTypeStorage,
+  CanvasBufferBindingTypeReadOnlyStorage,
+} CanvasBufferBindingType;
+
 typedef enum CanvasCompareFunction {
   CanvasCompareFunctionNever = 1,
   CanvasCompareFunctionLess = 2,
@@ -205,6 +243,16 @@ typedef enum CanvasCullMode {
   CanvasCullModeBack,
 } CanvasCullMode;
 
+typedef enum CanvasFilterMode {
+  CanvasFilterModeNearest = 0,
+  /**
+   * Linear Interpolation
+   *
+   * This makes textures smooth but blurry when used as a mag filter.
+   */
+  CanvasFilterModeLinear = 1,
+} CanvasFilterMode;
+
 typedef enum CanvasFrontFace {
   CanvasFrontFaceCcw = 0,
   CanvasFrontFaceCw = 1,
@@ -214,6 +262,14 @@ typedef enum CanvasGPUAutoLayoutMode {
   CanvasGPUAutoLayoutModeAuto,
 } CanvasGPUAutoLayoutMode;
 
+typedef enum CanvasGPUErrorType {
+  CanvasGPUErrorTypeNone,
+  CanvasGPUErrorTypeLost,
+  CanvasGPUErrorTypeOutOfMemory,
+  CanvasGPUErrorTypeValidation,
+  CanvasGPUErrorTypeInternal,
+} CanvasGPUErrorType;
+
 typedef enum CanvasGPUPowerPreference {
   CanvasGPUPowerPreferenceNone,
   CanvasGPUPowerPreferenceLowPower,
@@ -271,6 +327,28 @@ typedef enum CanvasPrimitiveTopology {
   CanvasPrimitiveTopologyTriangleStrip = 4,
 } CanvasPrimitiveTopology;
 
+typedef enum CanvasQueryType {
+  CanvasQueryTypeOcclusion,
+  CanvasQueryTypeTimestamp,
+} CanvasQueryType;
+
+typedef enum CanvasSamplerBindingType {
+  /**
+   * The sampling result is produced based on more than a single color sample from a texture,
+   * e.g. when bilinear interpolation is enabled.
+   */
+  CanvasSamplerBindingTypeFiltering,
+  /**
+   * The sampling result is produced based on a single color sample from a texture.
+   */
+  CanvasSamplerBindingTypeNonFiltering,
+  /**
+   * Use as a comparison sampler instead of a normal sampler.
+   * For more info take a look at the analogous functionality in OpenGL: <https://www.khronos.org/opengl/wiki/Sampler_Object#Comparison_mode>.
+   */
+  CanvasSamplerBindingTypeComparison,
+} CanvasSamplerBindingType;
+
 typedef enum CanvasStencilOperation {
   CanvasStencilOperationKeep = 0,
   CanvasStencilOperationZero = 1,
@@ -282,6 +360,64 @@ typedef enum CanvasStencilOperation {
   CanvasStencilOperationDecrementWrap = 7,
 } CanvasStencilOperation;
 
+typedef enum CanvasStorageTextureAccess {
+  /**
+   * The texture can only be written in the shader and it:
+   * - may or may not be annotated with `write` (WGSL).
+   * - must be annotated with `writeonly` (GLSL).
+   *
+   * Example WGSL syntax:
+   * ```rust,ignore
+   * @group(0) @binding(0)
+   * var my_storage_image: texture_storage_2d<f32, write>;
+   * ```
+   *
+   * Example GLSL syntax:
+   * ```cpp,ignore
+   * layout(set=0, binding=0, r32f) writeonly uniform image2D myStorageImage;
+   * ```
+   */
+  CanvasStorageTextureAccessWriteOnly,
+  /**
+   * The texture can only be read in the shader and it must be annotated with `read` (WGSL) or
+   * `readonly` (GLSL).
+   *
+   * [`Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES`] must be enabled to use this access
+   * mode. This is a native-only extension.
+   *
+   * Example WGSL syntax:
+   * ```rust,ignore
+   * @group(0) @binding(0)
+   * var my_storage_image: texture_storage_2d<f32, read>;
+   * ```
+   *
+   * Example GLSL syntax:
+   * ```cpp,ignore
+   * layout(set=0, binding=0, r32f) readonly uniform image2D myStorageImage;
+   * ```
+   */
+  CanvasStorageTextureAccessReadOnly,
+  /**
+   * The texture can be both read and written in the shader and must be annotated with
+   * `read_write` in WGSL.
+   *
+   * [`Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES`] must be enabled to use this access
+   * mode.  This is a nonstandard, native-only extension.
+   *
+   * Example WGSL syntax:
+   * ```rust,ignore
+   * @group(0) @binding(0)
+   * var my_storage_image: texture_storage_2d<f32, read_write>;
+   * ```
+   *
+   * Example GLSL syntax:
+   * ```cpp,ignore
+   * layout(set=0, binding=0, r32f) uniform image2D myStorageImage;
+   * ```
+   */
+  CanvasStorageTextureAccessReadWrite,
+} CanvasStorageTextureAccess;
+
 typedef enum CanvasStoreOp {
   CanvasStoreOpDiscard = 0,
   CanvasStoreOpStore = 1,
@@ -320,6 +456,23 @@ typedef enum CanvasTextureDimension {
   CanvasTextureDimensionD3,
 } CanvasTextureDimension;
 
+typedef enum CanvasTextureSampleType {
+  CanvasTextureSampleTypeFloat,
+  CanvasTextureSampleTypeUnfilterableFloat,
+  CanvasTextureSampleTypeDepth,
+  CanvasTextureSampleTypeSint,
+  CanvasTextureSampleTypeUint,
+} CanvasTextureSampleType;
+
+typedef enum CanvasTextureViewDimension {
+  CanvasTextureViewDimensionD1,
+  CanvasTextureViewDimensionD2,
+  CanvasTextureViewDimensionD2Array,
+  CanvasTextureViewDimensionCube,
+  CanvasTextureViewDimensionCubeArray,
+  CanvasTextureViewDimensionD3,
+} CanvasTextureViewDimension;
+
 typedef enum CanvasVertexFormat {
   CanvasVertexFormatUint8x2 = 0,
   CanvasVertexFormatUint8x4 = 1,
@@ -478,10 +631,14 @@ typedef struct CanvasGPUCommandBuffer CanvasGPUCommandBuffer;
 
 typedef struct CanvasGPUCommandEncoder CanvasGPUCommandEncoder;
 
-typedef struct CanvasGPUComputePass CanvasGPUComputePass;
+typedef struct CanvasGPUComputePassEncoder CanvasGPUComputePassEncoder;
+
+typedef struct CanvasGPUComputePipeline CanvasGPUComputePipeline;
 
 typedef struct CanvasGPUDevice CanvasGPUDevice;
 
+typedef struct CanvasGPUError CanvasGPUError;
+
 typedef struct CanvasGPUPipelineLayout CanvasGPUPipelineLayout;
 
 typedef struct CanvasGPUQuerySet CanvasGPUQuerySet;
@@ -490,10 +647,14 @@ typedef struct CanvasGPUQueue CanvasGPUQueue;
 
 typedef struct CanvasGPURenderBundle CanvasGPURenderBundle;
 
-typedef struct CanvasGPURenderPass CanvasGPURenderPass;
+typedef struct CanvasGPURenderBundleEncoder CanvasGPURenderBundleEncoder;
+
+typedef struct CanvasGPURenderPassEncoder CanvasGPURenderPassEncoder;
 
 typedef struct CanvasGPURenderPipeline CanvasGPURenderPipeline;
 
+typedef struct CanvasGPUSampler CanvasGPUSampler;
+
 typedef struct CanvasGPUShaderModule CanvasGPUShaderModule;
 
 typedef struct CanvasGPUTexture CanvasGPUTexture;
@@ -726,65 +887,21 @@ typedef struct CanvasExtent3d {
   uint32_t depth_or_array_layers;
 } CanvasExtent3d;
 
-typedef enum CanvasGPUPipelineLayoutOrGPUAutoLayoutMode_Tag {
-  CanvasGPUPipelineLayoutOrGPUAutoLayoutModeLayout,
-  CanvasGPUPipelineLayoutOrGPUAutoLayoutModeAuto,
-} CanvasGPUPipelineLayoutOrGPUAutoLayoutMode_Tag;
+typedef struct CanvasBufferBindingLayout {
+  enum CanvasBufferBindingType type_;
+  bool has_dynamic_offset;
+  int64_t min_binding_size;
+} CanvasBufferBindingLayout;
 
-typedef struct CanvasGPUPipelineLayoutOrGPUAutoLayoutMode {
-  CanvasGPUPipelineLayoutOrGPUAutoLayoutMode_Tag tag;
-  union {
-    struct {
-      const struct CanvasGPUPipelineLayout *layout;
-    };
-    struct {
-      enum CanvasGPUAutoLayoutMode auto_;
-    };
-  };
-} CanvasGPUPipelineLayoutOrGPUAutoLayoutMode;
-
-typedef struct CanvasVertexAttribute {
-  enum CanvasVertexFormat format;
-  uint64_t offset;
-  uint32_t shader_location;
-} CanvasVertexAttribute;
-
-typedef struct CanvasVertexBufferLayout {
-  uint64_t array_stride;
-  enum CanvasVertexStepMode step_mode;
-  const struct CanvasVertexAttribute *attributes;
-  uintptr_t attributes_size;
-} CanvasVertexBufferLayout;
+typedef struct CanvasSamplerBindingLayout {
+  enum CanvasSamplerBindingType type_;
+} CanvasSamplerBindingLayout;
 
-typedef struct CanvasVertexState {
-  const struct CanvasGPUShaderModule *module;
-  const char *entry_point;
-  const struct CanvasConstants *constants;
-  const struct CanvasVertexBufferLayout *buffers;
-  uintptr_t buffers_size;
-} CanvasVertexState;
-
-typedef enum CanvasOptionalIndexFormat_Tag {
-  CanvasOptionalIndexFormatNone,
-  CanvasOptionalIndexFormatSome,
-} CanvasOptionalIndexFormat_Tag;
-
-typedef struct CanvasOptionalIndexFormat {
-  CanvasOptionalIndexFormat_Tag tag;
-  union {
-    struct {
-      enum CanvasIndexFormat some;
-    };
-  };
-} CanvasOptionalIndexFormat;
-
-typedef struct CanvasPrimitiveState {
-  enum CanvasPrimitiveTopology topology;
-  struct CanvasOptionalIndexFormat strip_index_format;
-  enum CanvasFrontFace front_face;
-  enum CanvasCullMode cull_mode;
-  bool unclipped_depth;
-} CanvasPrimitiveState;
+typedef struct CanvasTextureBindingLayout {
+  enum CanvasTextureSampleType sample_type;
+  enum CanvasTextureViewDimension view_dimension;
+  bool multisampled;
+} CanvasTextureBindingLayout;
 
 typedef enum CanvasGPUTextureFormat_Tag {
   /**
@@ -1237,6 +1354,151 @@ typedef struct CanvasGPUTextureFormat {
   };
 } CanvasGPUTextureFormat;
 
+typedef struct CanvasStorageTextureBindingLayout {
+  enum CanvasStorageTextureAccess access;
+  struct CanvasGPUTextureFormat format;
+  enum CanvasTextureViewDimension view_dimension;
+} CanvasStorageTextureBindingLayout;
+
+typedef enum CanvasBindingType_Tag {
+  CanvasBindingTypeBuffer,
+  CanvasBindingTypeSampler,
+  CanvasBindingTypeTexture,
+  CanvasBindingTypeStorageTexture,
+} CanvasBindingType_Tag;
+
+typedef struct CanvasBindingType {
+  CanvasBindingType_Tag tag;
+  union {
+    struct {
+      struct CanvasBufferBindingLayout buffer;
+    };
+    struct {
+      struct CanvasSamplerBindingLayout sampler;
+    };
+    struct {
+      struct CanvasTextureBindingLayout texture;
+    };
+    struct {
+      struct CanvasStorageTextureBindingLayout storage_texture;
+    };
+  };
+} CanvasBindingType;
+
+typedef struct CanvasBindGroupLayoutEntry {
+  uint32_t binding;
+  uint32_t visibility;
+  struct CanvasBindingType binding_type;
+} CanvasBindGroupLayoutEntry;
+
+typedef struct CanvasBufferBinding {
+  const struct CanvasGPUBuffer *buffer;
+  int64_t offset;
+  int64_t size;
+} CanvasBufferBinding;
+
+typedef enum CanvasBindGroupEntryResource_Tag {
+  CanvasBindGroupEntryResourceBuffer,
+  CanvasBindGroupEntryResourceSampler,
+  CanvasBindGroupEntryResourceTextureView,
+} CanvasBindGroupEntryResource_Tag;
+
+typedef struct CanvasBindGroupEntryResource {
+  CanvasBindGroupEntryResource_Tag tag;
+  union {
+    struct {
+      struct CanvasBufferBinding buffer;
+    };
+    struct {
+      const struct CanvasGPUSampler *sampler;
+    };
+    struct {
+      const struct CanvasGPUTextureView *texture_view;
+    };
+  };
+} CanvasBindGroupEntryResource;
+
+typedef struct CanvasBindGroupEntry {
+  uint32_t binding;
+  struct CanvasBindGroupEntryResource resource;
+} CanvasBindGroupEntry;
+
+typedef enum CanvasGPUPipelineLayoutOrGPUAutoLayoutMode_Tag {
+  CanvasGPUPipelineLayoutOrGPUAutoLayoutModeLayout,
+  CanvasGPUPipelineLayoutOrGPUAutoLayoutModeAuto,
+} CanvasGPUPipelineLayoutOrGPUAutoLayoutMode_Tag;
+
+typedef struct CanvasGPUPipelineLayoutOrGPUAutoLayoutMode {
+  CanvasGPUPipelineLayoutOrGPUAutoLayoutMode_Tag tag;
+  union {
+    struct {
+      const struct CanvasGPUPipelineLayout *layout;
+    };
+    struct {
+      enum CanvasGPUAutoLayoutMode auto_;
+    };
+  };
+} CanvasGPUPipelineLayoutOrGPUAutoLayoutMode;
+
+typedef struct CanvasProgrammableStage {
+  const struct CanvasGPUShaderModule *module;
+  const char *entry_point;
+  const struct CanvasConstants *constants;
+} CanvasProgrammableStage;
+
+typedef struct CanvasCreateRenderBundleEncoderDescriptor {
+  const char *label;
+  const struct CanvasGPUTextureFormat *color_formats;
+  uintptr_t color_formats_size;
+  const struct CanvasGPUTextureFormat *depth_stencil_format;
+  uint32_t sample_count;
+  bool depth_read_only;
+  bool stencil_read_only;
+} CanvasCreateRenderBundleEncoderDescriptor;
+
+typedef struct CanvasVertexAttribute {
+  enum CanvasVertexFormat format;
+  uint64_t offset;
+  uint32_t shader_location;
+} CanvasVertexAttribute;
+
+typedef struct CanvasVertexBufferLayout {
+  uint64_t array_stride;
+  enum CanvasVertexStepMode step_mode;
+  const struct CanvasVertexAttribute *attributes;
+  uintptr_t attributes_size;
+} CanvasVertexBufferLayout;
+
+typedef struct CanvasVertexState {
+  const struct CanvasGPUShaderModule *module;
+  const char *entry_point;
+  const struct CanvasConstants *constants;
+  const struct CanvasVertexBufferLayout *buffers;
+  uintptr_t buffers_size;
+} CanvasVertexState;
+
+typedef enum CanvasOptionalIndexFormat_Tag {
+  CanvasOptionalIndexFormatNone,
+  CanvasOptionalIndexFormatSome,
+} CanvasOptionalIndexFormat_Tag;
+
+typedef struct CanvasOptionalIndexFormat {
+  CanvasOptionalIndexFormat_Tag tag;
+  union {
+    struct {
+      enum CanvasIndexFormat some;
+    };
+  };
+} CanvasOptionalIndexFormat;
+
+typedef struct CanvasPrimitiveState {
+  enum CanvasPrimitiveTopology topology;
+  struct CanvasOptionalIndexFormat strip_index_format;
+  enum CanvasFrontFace front_face;
+  enum CanvasCullMode cull_mode;
+  bool unclipped_depth;
+} CanvasPrimitiveState;
+
 typedef struct CanvasStencilFaceState {
   enum CanvasCompareFunction compare;
   enum CanvasStencilOperation fail_op;
@@ -1356,6 +1618,34 @@ typedef struct CanvasCreateTextureDescriptor {
   uintptr_t view_formats_size;
 } CanvasCreateTextureDescriptor;
 
+typedef enum CanvasOptionalCompareFunction_Tag {
+  CanvasOptionalCompareFunctionNone,
+  CanvasOptionalCompareFunctionSome,
+} CanvasOptionalCompareFunction_Tag;
+
+typedef struct CanvasOptionalCompareFunction {
+  CanvasOptionalCompareFunction_Tag tag;
+  union {
+    struct {
+      enum CanvasCompareFunction some;
+    };
+  };
+} CanvasOptionalCompareFunction;
+
+typedef struct CanvasCreateSamplerDescriptor {
+  const char *label;
+  enum CanvasAddressMode address_mode_u;
+  enum CanvasAddressMode address_mode_v;
+  enum CanvasAddressMode address_mode_w;
+  enum CanvasFilterMode mag_filter;
+  enum CanvasFilterMode min_filter;
+  enum CanvasFilterMode mipmap_filter;
+  float lod_min_clamp;
+  float lod_max_clamp;
+  struct CanvasOptionalCompareFunction compare;
+  uint16_t max_anisotropy;
+} CanvasCreateSamplerDescriptor;
+
 typedef struct CanvasOrigin2d {
   /**
    *
@@ -4085,9 +4375,9 @@ void canvas_native_matrix_destroy(struct Matrix *value);
 
 void canvas_native_path_destroy(struct Path *value);
 
-struct CanvasWebGPUInstance *canvas_native_webgpu_instance_create(void);
+const struct CanvasWebGPUInstance *canvas_native_webgpu_instance_create(void);
 
-void canvas_native_webgpu_instance_destroy(struct CanvasWebGPUInstance *instance);
+void canvas_native_webgpu_instance_release(const struct CanvasWebGPUInstance *instance);
 
 void canvas_native_webgpu_request_adapter(const struct CanvasWebGPUInstance *instance,
                                           const struct CanvasGPURequestAdapterOptions *options,
@@ -4096,13 +4386,15 @@ void canvas_native_webgpu_request_adapter(const struct CanvasWebGPUInstance *ins
 
 char *canvas_native_webgpu_adapter_info_vendor(const struct CanvasGPUAdapterInfo *info);
 
-char *canvas_native_webgpu_adapter_info_architecture(const struct CanvasGPUAdapterInfo *info);
+char *canvas_native_webgpu_adapter_info_architecture(const struct CanvasGPUAdapterInfo *_info);
 
 char *canvas_native_webgpu_adapter_info_device(const struct CanvasGPUAdapterInfo *info);
 
 char *canvas_native_webgpu_adapter_info_description(const struct CanvasGPUAdapterInfo *info);
 
-void canvas_native_webgpu_adapter_info_destroy(struct CanvasGPUAdapterInfo *info);
+void canvas_native_webgpu_adapter_info_reference(const struct CanvasGPUAdapterInfo *info);
+
+void canvas_native_webgpu_adapter_info_release(const struct CanvasGPUAdapterInfo *info);
 
 struct StringBuffer *canvas_native_webgpu_adapter_get_features(const struct CanvasGPUAdapter *adapter);
 
@@ -4110,25 +4402,27 @@ bool canvas_native_webgpu_adapter_is_fallback_adapter(const struct CanvasGPUAdap
 
 struct CanvasGPUSupportedLimits *canvas_native_webgpu_adapter_get_limits(const struct CanvasGPUAdapter *adapter);
 
-struct CanvasGPUAdapterInfo *canvas_native_webgpu_request_adapter_info(struct CanvasGPUAdapter *adapter);
+const struct CanvasGPUAdapterInfo *canvas_native_webgpu_request_adapter_info(struct CanvasGPUAdapter *adapter);
 
-void canvas_native_webgpu_request_device(struct CanvasGPUAdapter *adapter,
+void canvas_native_webgpu_request_device(const struct CanvasGPUAdapter *adapter,
                                          const char *label,
                                          const char *const *required_features,
                                          uintptr_t required_features_length,
                                          const struct CanvasGPUSupportedLimits *required_limits,
-                                         void (*callback)(char*, struct CanvasGPUDevice*, void*),
+                                         void (*callback)(char*,
+                                                          const struct CanvasGPUDevice*,
+                                                          void*),
                                          void *callback_data);
 
 uint32_t canvas_native_webgpu_buffer_usage(const struct CanvasGPUBuffer *buffer);
 
 uint64_t canvas_native_webgpu_buffer_size(const struct CanvasGPUBuffer *buffer);
 
-char *canvas_native_webgpu_buffer_get_mapped_range(const struct CanvasGPUBuffer *buffer,
-                                                   int64_t offset,
-                                                   int64_t size,
-                                                   uint8_t *dst,
-                                                   uintptr_t dst_size);
+void canvas_native_webgpu_buffer_get_mapped_range(const struct CanvasGPUBuffer *buffer,
+                                                  int64_t offset,
+                                                  int64_t size,
+                                                  uint8_t *dst,
+                                                  uintptr_t dst_size);
 
 void canvas_native_webgpu_buffer_destroy(const struct CanvasGPUBuffer *buffer);
 
@@ -4141,95 +4435,173 @@ void canvas_native_webgpu_buffer_map_async(const struct CanvasGPUBuffer *buffer,
                                            void (*callback)(char*, void*),
                                            void *callback_data);
 
-struct CanvasGPUComputePass *canvas_native_webgpu_command_encoder_begin_compute_pass(struct CanvasGPUCommandEncoder *command_encoder,
-                                                                                     const struct CanvasGPUQuerySet *query_set,
-                                                                                     const char *label,
-                                                                                     int32_t beginning_of_pass_write_index,
-                                                                                     int32_t end_of_pass_write_index);
-
-struct CanvasGPURenderPass *canvas_native_webgpu_command_encoder_begin_render_pass(struct CanvasGPUCommandEncoder *command_encoder,
-                                                                                   const char *label,
-                                                                                   const struct CanvasRenderPassColorAttachment *color_attachments,
-                                                                                   uintptr_t color_attachments_size,
-                                                                                   const struct CanvasRenderPassDepthStencilAttachment *depth_stencil_attachment,
-                                                                                   const struct CanvasGPUQuerySet *occlusion_query_set,
-                                                                                   const struct CanvasGPUQuerySet *query_set,
-                                                                                   int32_t beginning_of_pass_write_index,
-                                                                                   int32_t end_of_pass_write_index);
-
-void canvas_native_webgpu_command_encoder_clear_buffer(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_reference(const struct CanvasGPUCommandEncoder *command_encoder);
+
+void canvas_native_webgpu_command_encoder_release(const struct CanvasGPUCommandEncoder *command_encoder);
+
+const struct CanvasGPUComputePassEncoder *canvas_native_webgpu_command_encoder_begin_compute_pass(const struct CanvasGPUCommandEncoder *command_encoder,
+                                                                                                  const struct CanvasGPUQuerySet *query_set,
+                                                                                                  const char *label,
+                                                                                                  int32_t beginning_of_pass_write_index,
+                                                                                                  int32_t end_of_pass_write_index);
+
+const struct CanvasGPURenderPassEncoder *canvas_native_webgpu_command_encoder_begin_render_pass(const struct CanvasGPUCommandEncoder *command_encoder,
+                                                                                                const char *label,
+                                                                                                const struct CanvasRenderPassColorAttachment *color_attachments,
+                                                                                                uintptr_t color_attachments_size,
+                                                                                                const struct CanvasRenderPassDepthStencilAttachment *depth_stencil_attachment,
+                                                                                                const struct CanvasGPUQuerySet *occlusion_query_set,
+                                                                                                const struct CanvasGPUQuerySet *query_set,
+                                                                                                int32_t beginning_of_pass_write_index,
+                                                                                                int32_t end_of_pass_write_index);
+
+void canvas_native_webgpu_command_encoder_clear_buffer(const struct CanvasGPUCommandEncoder *command_encoder,
                                                        const struct CanvasGPUBuffer *buffer,
                                                        int64_t offset,
                                                        int64_t size);
 
-void canvas_native_webgpu_command_encoder_copy_buffer_to_buffer(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_copy_buffer_to_buffer(const struct CanvasGPUCommandEncoder *command_encoder,
                                                                 const struct CanvasGPUBuffer *src,
                                                                 int64_t src_offset,
                                                                 const struct CanvasGPUBuffer *dst,
                                                                 int64_t dst_offset,
                                                                 uint64_t size);
 
-void canvas_native_webgpu_command_encoder_copy_buffer_to_texture(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_copy_buffer_to_texture(const struct CanvasGPUCommandEncoder *command_encoder,
                                                                  const struct CanvasImageCopyBuffer *src,
                                                                  const struct CanvasImageCopyTexture *dst,
                                                                  const struct CanvasExtent3d *copy_size);
 
-void canvas_native_webgpu_command_encoder_copy_texture_to_buffer(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_copy_texture_to_buffer(const struct CanvasGPUCommandEncoder *command_encoder,
                                                                  const struct CanvasImageCopyTexture *src,
                                                                  const struct CanvasImageCopyBuffer *dst,
                                                                  const struct CanvasExtent3d *copy_size);
 
-void canvas_native_webgpu_command_encoder_copy_texture_to_texture(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_copy_texture_to_texture(const struct CanvasGPUCommandEncoder *command_encoder,
                                                                   const struct CanvasImageCopyTexture *src,
                                                                   const struct CanvasImageCopyTexture *dst,
                                                                   const struct CanvasExtent3d *copy_size);
 
-struct CanvasGPUCommandBuffer *canvas_native_webgpu_command_encoder_finish(struct CanvasGPUCommandEncoder *command_encoder,
-                                                                           const char *label);
+const struct CanvasGPUCommandBuffer *canvas_native_webgpu_command_encoder_finish(const struct CanvasGPUCommandEncoder *command_encoder,
+                                                                                 const char *label);
 
-void canvas_native_webgpu_command_encoder_pop_debug_group(struct CanvasGPUCommandEncoder *command_encoder);
+void canvas_native_webgpu_command_encoder_pop_debug_group(const struct CanvasGPUCommandEncoder *command_encoder);
 
-void canvas_native_webgpu_command_encoder_push_debug_group(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_push_debug_group(const struct CanvasGPUCommandEncoder *command_encoder,
                                                            const char *label);
 
-void canvas_native_webgpu_command_encoder_resolve_query_set(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_resolve_query_set(const struct CanvasGPUCommandEncoder *command_encoder,
                                                             const struct CanvasGPUQuerySet *query_set,
                                                             uint32_t first_query,
                                                             uint32_t query_count,
                                                             struct CanvasGPUBuffer *dst,
                                                             uint64_t dst_offset);
 
-void canvas_native_webgpu_command_encoder_write_timestamp(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_write_timestamp(const struct CanvasGPUCommandEncoder *command_encoder,
                                                           const struct CanvasGPUQuerySet *query_set,
                                                           uint32_t query_index);
 
+void canvas_native_webgpu_compute_pass_reference(const struct CanvasGPUComputePassEncoder *compute_pass);
+
+void canvas_native_webgpu_compute_pass_release(const struct CanvasGPUComputePassEncoder *compute_pass);
+
+void canvas_native_webgpu_compute_pass_dispatch_workgroups(const struct CanvasGPUComputePassEncoder *compute_pass,
+                                                           uint32_t workgroup_count_x,
+                                                           uint32_t workgroup_count_y,
+                                                           uint32_t workgroup_count_z);
+
+void canvas_native_webgpu_compute_pass_dispatch_workgroups_indirect(const struct CanvasGPUComputePassEncoder *compute_pass,
+                                                                    const struct CanvasGPUBuffer *indirect_buffer,
+                                                                    uintptr_t indirect_offset);
+
+void canvas_native_webgpu_compute_pass_end(const struct CanvasGPUComputePassEncoder *compute_pass);
+
+void canvas_native_webgpu_compute_pass_insert_debug_marker(const struct CanvasGPUComputePassEncoder *compute_pass,
+                                                           const char *label);
+
+void canvas_native_webgpu_compute_pass_pop_debug_group(const struct CanvasGPUComputePassEncoder *compute_pass);
+
+void canvas_native_webgpu_compute_pass_push_debug_group(const struct CanvasGPUComputePassEncoder *compute_pass,
+                                                        const char *label);
+
+void canvas_native_webgpu_compute_pass_set_bind_group(const struct CanvasGPUComputePassEncoder *compute_pass,
+                                                      uint32_t index,
+                                                      const struct CanvasGPUBindGroup *bind_group,
+                                                      const uint32_t *dynamic_offsets,
+                                                      uintptr_t dynamic_offsets_size,
+                                                      uintptr_t dynamic_offsets_start,
+                                                      uintptr_t dynamic_offsets_length);
+
+void canvas_native_webgpu_compute_pass_set_pipeline(struct CanvasGPUComputePassEncoder *compute_pass,
+                                                    const struct CanvasGPUComputePipeline *pipeline);
+
 struct StringBuffer *canvas_native_webgpu_device_get_features(const struct CanvasGPUDevice *device);
 
 struct CanvasGPUSupportedLimits *canvas_native_webgpu_device_get_limits(const struct CanvasGPUDevice *device);
 
-struct CanvasGPUQueue *canvas_native_webgpu_device_get_queue(const struct CanvasGPUDevice *device);
+const struct CanvasGPUQueue *canvas_native_webgpu_device_get_queue(const struct CanvasGPUDevice *device);
 
 void canvas_native_webgpu_device_set_lost_callback(const struct CanvasGPUDevice *device,
                                                    void (*callback)(int32_t, char*, void*),
-                                                   void *callback_data);
+                                                   void *userdata);
 
 void canvas_native_webgpu_device_destroy(const struct CanvasGPUDevice *device);
 
-void canvas_native_webgpu_device_destroy_destory(struct CanvasGPUDevice *device);
+void canvas_native_webgpu_device_reference(const struct CanvasGPUDevice *device);
 
-struct CanvasGPUCommandEncoder *canvas_native_webgpu_device_create_command_encoder(const struct CanvasGPUDevice *device,
-                                                                                   const char *label);
+void canvas_native_webgpu_device_release(const struct CanvasGPUDevice *device);
 
-struct CanvasGPUShaderModule *canvas_native_webgpu_device_create_shader_module(const struct CanvasGPUDevice *device,
+const struct CanvasGPUBindGroupLayout *canvas_native_webgpu_device_create_bind_group_layout(const struct CanvasGPUDevice *device,
+                                                                                            const char *label,
+                                                                                            const struct CanvasBindGroupLayoutEntry *entries,
+                                                                                            uintptr_t size);
+
+const struct CanvasGPUBindGroup *canvas_native_webgpu_device_create_bind_group(const struct CanvasGPUDevice *device,
                                                                                const char *label,
-                                                                               const char *source);
+                                                                               const struct CanvasGPUBindGroupLayout *layout,
+                                                                               const struct CanvasBindGroupEntry *entries,
+                                                                               uintptr_t size);
+
+const struct CanvasGPUCommandEncoder *canvas_native_webgpu_device_create_command_encoder(const struct CanvasGPUDevice *device,
+                                                                                         const char *label);
+
+const struct CanvasGPUComputePipeline *canvas_native_webgpu_device_create_compute_pipeline(const struct CanvasGPUDevice *device,
+                                                                                           const char *label,
+                                                                                           struct CanvasGPUPipelineLayoutOrGPUAutoLayoutMode layout,
+                                                                                           const struct CanvasProgrammableStage *compute);
+
+void canvas_native_webgpu_device_create_compute_pipeline_async(const struct CanvasGPUDevice *device,
+                                                               const char *label,
+                                                               struct CanvasGPUPipelineLayoutOrGPUAutoLayoutMode layout,
+                                                               const struct CanvasProgrammableStage *compute,
+                                                               void (*callback)(const struct CanvasGPUComputePipeline*,
+                                                                                enum CanvasGPUErrorType,
+                                                                                char*,
+                                                                                void*),
+                                                               void *callback_data);
+
+const struct CanvasGPUPipelineLayout *canvas_native_webgpu_device_create_pipeline_layout(const struct CanvasGPUDevice *device,
+                                                                                         const char *label,
+                                                                                         const struct CanvasGPUBindGroupLayout *group_layouts,
+                                                                                         uintptr_t size);
+
+const struct CanvasGPUQuerySet *canvas_native_webgpu_device_create_query_set(const struct CanvasGPUDevice *device,
+                                                                             const char *label,
+                                                                             enum CanvasQueryType type_,
+                                                                             uint32_t count);
+
+const struct CanvasGPURenderBundleEncoder *canvas_native_webgpu_device_create_render_bundle_encoder(const struct CanvasGPUDevice *device,
+                                                                                                    const struct CanvasCreateRenderBundleEncoderDescriptor *descriptor);
+
+const struct CanvasGPUShaderModule *canvas_native_webgpu_device_create_shader_module(const struct CanvasGPUDevice *device,
+                                                                                     const char *label,
+                                                                                     const char *source);
 
-struct CanvasGPUBuffer *canvas_native_webgpu_device_create_buffer(const struct CanvasGPUDevice *device,
-                                                                  const char *label,
-                                                                  uint64_t size,
-                                                                  uint32_t usage,
-                                                                  bool mapped_at_creation,
-                                                                  char *error);
+const struct CanvasGPUBuffer *canvas_native_webgpu_device_create_buffer(const struct CanvasGPUDevice *device,
+                                                                        const char *label,
+                                                                        uint64_t size,
+                                                                        uint32_t usage,
+                                                                        bool mapped_at_creation);
 
 struct CanvasConstants *canvas_native_webgpu_constants_create(void);
 
@@ -4239,35 +4611,45 @@ void canvas_native_webgpu_constants_insert(struct CanvasConstants *constants,
 
 void canvas_native_webgpu_constants_destroy(struct CanvasConstants *constants);
 
-struct CanvasGPURenderPipeline *canvas_native_webgpu_device_create_render_pipeline(const struct CanvasGPUDevice *device,
-                                                                                   const struct CanvasCreateRenderPipelineDescriptor *descriptor);
+const struct CanvasGPURenderPipeline *canvas_native_webgpu_device_create_render_pipeline(const struct CanvasGPUDevice *device,
+                                                                                         const struct CanvasCreateRenderPipelineDescriptor *descriptor);
 
-struct CanvasGPUTexture *canvas_native_webgpu_device_create_texture(const struct CanvasGPUDevice *device,
-                                                                    const struct CanvasCreateTextureDescriptor *descriptor,
-                                                                    char *error);
+void canvas_native_webgpu_device_create_render_pipeline_async(const struct CanvasGPUDevice *device,
+                                                              const struct CanvasCreateRenderPipelineDescriptor *descriptor,
+                                                              void (*callback)(const struct CanvasGPURenderPipeline*,
+                                                                               enum CanvasGPUErrorType,
+                                                                               char*,
+                                                                               void*),
+                                                              void *callback_data);
 
-void canvas_native_webgpu_queue_copy_external_image_to_texture(struct CanvasGPUQueue *queue,
+const struct CanvasGPUTexture *canvas_native_webgpu_device_create_texture(const struct CanvasGPUDevice *device,
+                                                                          const struct CanvasCreateTextureDescriptor *descriptor);
+
+const struct CanvasGPUSampler *canvas_native_webgpu_device_create_sampler(const struct CanvasGPUDevice *device,
+                                                                          const struct CanvasCreateSamplerDescriptor *descriptor);
+
+void canvas_native_webgpu_queue_copy_external_image_to_texture(const struct CanvasGPUQueue *queue,
                                                                const struct CanvasImageCopyExternalImage *source,
                                                                const struct CanvasImageCopyTexture *destination,
                                                                const struct CanvasExtent3d *size);
 
-void canvas_native_webgpu_queue_on_submitted_work_done(struct CanvasGPUQueue *queue,
+void canvas_native_webgpu_queue_on_submitted_work_done(const struct CanvasGPUQueue *queue,
                                                        void (*callback)(char*, void*),
                                                        void *callback_data);
 
-void canvas_native_webgpu_queue_submit(struct CanvasGPUQueue *queue,
+void canvas_native_webgpu_queue_submit(const struct CanvasGPUQueue *queue,
                                        const struct CanvasGPUCommandBuffer *const *command_buffers,
                                        uintptr_t command_buffers_size);
 
-void canvas_native_webgpu_queue_write_buffer(struct CanvasGPUQueue *queue,
-                                             struct CanvasGPUBuffer *buffer,
+void canvas_native_webgpu_queue_write_buffer(const struct CanvasGPUQueue *queue,
+                                             const struct CanvasGPUBuffer *buffer,
                                              uint64_t buffer_offset,
                                              const uint8_t *data,
                                              uintptr_t data_size,
                                              uintptr_t data_offset,
                                              intptr_t size);
 
-void canvas_native_webgpu_queue_write_texture(struct CanvasGPUQueue *queue,
+void canvas_native_webgpu_queue_write_texture(const struct CanvasGPUQueue *queue,
                                               const struct CanvasImageCopyTexture *destination,
                                               const struct CanvasImageDataLayout *data_layout,
                                               const struct CanvasExtent3d *size,
@@ -4276,49 +4658,49 @@ void canvas_native_webgpu_queue_write_texture(struct CanvasGPUQueue *queue,
 
 struct CanvasGPUSupportedLimits *canvas_native_webgpu_create_limits(void);
 
-void canvas_native_webgpu_limits_destroy(struct CanvasGPUSupportedLimits *limits);
+void canvas_native_webgpu_limits_release(struct CanvasGPUSupportedLimits *limits);
 
-void canvas_native_webgpu_render_pass_begin_occlusion_query(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_begin_occlusion_query(const struct CanvasGPURenderPassEncoder *render_pass,
                                                             uint32_t query_index);
 
-void canvas_native_webgpu_render_pass_encoder_draw(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_encoder_draw(const struct CanvasGPURenderPassEncoder *render_pass,
                                                    uint32_t vertex_count,
                                                    uint32_t instance_count,
                                                    uint32_t first_vertex,
                                                    uint32_t first_instance);
 
-void canvas_native_webgpu_render_pass_draw_indexed(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_draw_indexed(const struct CanvasGPURenderPassEncoder *render_pass,
                                                    uint32_t index_count,
                                                    uint32_t instance_count,
                                                    uint32_t first_index,
                                                    int32_t base_vertex,
                                                    uint32_t first_instance);
 
-void canvas_native_webgpu_render_pass_draw_indexed_indirect(struct CanvasGPURenderPass *render_pass,
-                                                            struct CanvasGPUBuffer *indirect_buffer,
+void canvas_native_webgpu_render_pass_draw_indexed_indirect(const struct CanvasGPURenderPassEncoder *render_pass,
+                                                            const struct CanvasGPUBuffer *indirect_buffer,
                                                             uint64_t indirect_offset);
 
-void canvas_native_webgpu_render_pass_draw_indirect(struct CanvasGPURenderPass *render_pass,
-                                                    struct CanvasGPUBuffer *indirect_buffer,
+void canvas_native_webgpu_render_pass_draw_indirect(const struct CanvasGPURenderPassEncoder *render_pass,
+                                                    const struct CanvasGPUBuffer *indirect_buffer,
                                                     uint64_t indirect_offset);
 
-void canvas_native_webgpu_render_pass_end(struct CanvasGPURenderPass *render_pass);
+void canvas_native_webgpu_render_pass_end(const struct CanvasGPURenderPassEncoder *render_pass);
 
-void canvas_native_webgpu_render_pass_end_occlusion_query(struct CanvasGPURenderPass *render_pass);
+void canvas_native_webgpu_render_pass_end_occlusion_query(const struct CanvasGPURenderPassEncoder *render_pass);
 
-void canvas_native_webgpu_render_pass_execute_bundles(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_execute_bundles(const struct CanvasGPURenderPassEncoder *render_pass,
                                                       const struct CanvasGPURenderBundle *bundles,
                                                       uintptr_t bundles_size);
 
-void canvas_native_webgpu_render_pass_insert_debug_marker(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_insert_debug_marker(const struct CanvasGPURenderPassEncoder *render_pass,
                                                           const char *label);
 
-void canvas_native_webgpu_render_pass_pop_debug_group(struct CanvasGPURenderPass *render_pass);
+void canvas_native_webgpu_render_pass_pop_debug_group(const struct CanvasGPURenderPassEncoder *render_pass);
 
-void canvas_native_webgpu_render_pass_push_debug_group(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_push_debug_group(const struct CanvasGPURenderPassEncoder *render_pass,
                                                        const char *label);
 
-void canvas_native_webgpu_render_pass_set_bind_group(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_bind_group(const struct CanvasGPURenderPassEncoder *render_pass,
                                                      uint32_t index,
                                                      const struct CanvasGPUBindGroup *bind_group,
                                                      const uint32_t *dynamic_offsets,
@@ -4326,34 +4708,34 @@ void canvas_native_webgpu_render_pass_set_bind_group(struct CanvasGPURenderPass
                                                      uintptr_t dynamic_offsets_start,
                                                      uintptr_t dynamic_offsets_length);
 
-void canvas_native_webgpu_render_pass_set_blend_constant(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_blend_constant(const struct CanvasGPURenderPassEncoder *render_pass,
                                                          const struct CanvasColor *color);
 
-void canvas_native_webgpu_render_pass_set_index_buffer(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_index_buffer(const struct CanvasGPURenderPassEncoder *render_pass,
                                                        const struct CanvasGPUBuffer *buffer,
                                                        enum CanvasIndexFormat index_format,
                                                        int64_t offset,
                                                        int64_t size);
 
-void canvas_native_webgpu_render_pass_set_pipeline(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_pipeline(const struct CanvasGPURenderPassEncoder *render_pass,
                                                    const struct CanvasGPURenderPipeline *pipeline);
 
-void canvas_native_webgpu_render_pass_set_scissor_rect(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_scissor_rect(const struct CanvasGPURenderPassEncoder *render_pass,
                                                        uint32_t x,
                                                        uint32_t y,
                                                        uint32_t width,
                                                        uint32_t height);
 
-void canvas_native_webgpu_render_pass_set_stencil_reference(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_stencil_reference(const struct CanvasGPURenderPassEncoder *render_pass,
                                                             uint32_t reference);
 
-void canvas_native_webgpu_render_pass_set_vertex_buffer(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_vertex_buffer(const struct CanvasGPURenderPassEncoder *render_pass,
                                                         uint32_t slot,
-                                                        struct CanvasGPUBuffer *buffer,
+                                                        const struct CanvasGPUBuffer *buffer,
                                                         int64_t offset,
                                                         int64_t size);
 
-void canvas_native_webgpu_render_pass_set_viewport(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_viewport(const struct CanvasGPURenderPassEncoder *render_pass,
                                                    float x,
                                                    float y,
                                                    float width,
@@ -4361,73 +4743,105 @@ void canvas_native_webgpu_render_pass_set_viewport(struct CanvasGPURenderPass *r
                                                    float depth_min,
                                                    float depth_max);
 
+void canvas_native_webgpu_render_pass_reference(const struct CanvasGPURenderPassEncoder *render_pass);
+
+void canvas_native_webgpu_render_pass_release(const struct CanvasGPURenderPassEncoder *render_pass);
+
 #if defined(TARGET_OS_ANDROID)
-struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create(struct CanvasWebGPUInstance *instance,
-                                                                   void *window,
-                                                                   uint32_t width,
-                                                                   uint32_t height);
+const struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create(struct CanvasWebGPUInstance *instance,
+                                                                         void *window,
+                                                                         uint32_t width,
+                                                                         uint32_t height);
 #endif
 
 #if (defined(TARGET_OS_IOS) || defined(TARGET_OS_MACOS))
-struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create(struct CanvasWebGPUInstance *instance,
-                                                                   void *view,
-                                                                   uint32_t width,
-                                                                   uint32_t height);
+const struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create(const struct CanvasWebGPUInstance *instance,
+                                                                         void *view,
+                                                                         uint32_t width,
+                                                                         uint32_t height);
 #endif
 
 #if defined(TARGET_OS_IOS)
-struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create_uiview(struct CanvasWebGPUInstance *instance,
-                                                                          void *view,
-                                                                          uint32_t width,
-                                                                          uint32_t height);
+const struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create_uiview(const struct CanvasWebGPUInstance *instance,
+                                                                                void *view,
+                                                                                uint32_t width,
+                                                                                uint32_t height);
 #endif
 
 #if defined(TARGET_OS_MACOS)
-struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create_nsview(struct CanvasWebGPUInstance *instance,
-                                                                          void *view,
-                                                                          uint32_t width,
-                                                                          uint32_t height);
+const struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create_nsview(const struct CanvasWebGPUInstance *instance,
+                                                                                void *view,
+                                                                                uint32_t width,
+                                                                                uint32_t height);
 #endif
 
-void canvas_native_webgpu_context_configure(struct CanvasGPUCanvasContext *context,
-                                            struct CanvasGPUDevice *device,
+void canvas_native_webgpu_context_configure(const struct CanvasGPUCanvasContext *context,
+                                            const struct CanvasGPUDevice *device,
                                             const struct CanvasGPUSurfaceConfiguration *config);
 
-void canvas_native_webgpu_context_unconfigure(struct CanvasGPUCanvasContext *context,
+void canvas_native_webgpu_context_unconfigure(const struct CanvasGPUCanvasContext *context,
                                               struct CanvasGPUDevice *device,
                                               const struct CanvasGPUSurfaceConfiguration *config);
 
-struct CanvasGPUTexture *canvas_native_webgpu_context_get_current_texture(struct CanvasGPUCanvasContext *context);
+const struct CanvasGPUTexture *canvas_native_webgpu_context_get_current_texture(const struct CanvasGPUCanvasContext *context);
+
+void canvas_native_webgpu_context_present_surface(const struct CanvasGPUCanvasContext *context);
+
+void canvas_native_webgpu_context_get_capabilities(const struct CanvasGPUCanvasContext *context,
+                                                   const struct CanvasGPUAdapter *adapter);
 
 char *canvas_native_webgpu_enum_gpu_texture_to_string(struct CanvasGPUTextureFormat value);
 
 struct CanvasOptionalGPUTextureFormat canvas_native_webgpu_string_to_gpu_texture_enum(const char *format);
 
-struct CanvasGPUTextureView *canvas_native_webgpu_texture_create_texture_view(struct CanvasGPUTexture *texture,
-                                                                              const struct CanvasCreateTextureViewDescriptor *descriptor);
+void canvas_native_webgpu_texture_reference(const struct CanvasGPUTexture *texture);
+
+void canvas_native_webgpu_texture_release(const struct CanvasGPUTexture *texture);
+
+const struct CanvasGPUTextureView *canvas_native_webgpu_texture_create_texture_view(const struct CanvasGPUTexture *texture,
+                                                                                    const struct CanvasCreateTextureViewDescriptor *descriptor);
+
+uint32_t canvas_native_webgpu_texture_get_depth_or_array_layers(const struct CanvasGPUTexture *texture);
+
+uint32_t canvas_native_webgpu_texture_get_width(const struct CanvasGPUTexture *texture);
+
+uint32_t canvas_native_webgpu_texture_get_height(const struct CanvasGPUTexture *texture);
+
+enum CanvasTextureDimension canvas_native_webgpu_texture_get_dimension(const struct CanvasGPUTexture *texture);
+
+struct CanvasGPUTextureFormat canvas_native_webgpu_texture_get_format(const struct CanvasGPUTexture *texture);
+
+uint32_t canvas_native_webgpu_texture_get_usage(const struct CanvasGPUTexture *texture);
+
+char *canvas_native_webgpu_texture_get_label(const struct CanvasGPUTexture *_texture);
+
+uint32_t canvas_native_webgpu_texture_get_mip_level_count(const struct CanvasGPUTexture *texture);
+
+uint32_t canvas_native_webgpu_texture_get_sample_count(const struct CanvasGPUTexture *texture);
 
-uint32_t canvas_native_webgpu_texture_get_depth_or_array_layers(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_texture_destroy(const struct CanvasGPUTexture *texture);
 
-uint32_t canvas_native_webgpu_texture_get_width(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_texture_view_reference(const struct CanvasGPUTextureView *texture_view);
 
-uint32_t canvas_native_webgpu_texture_get_height(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_texture_view_release(const struct CanvasGPUTextureView *texture_view);
 
-enum CanvasTextureDimension canvas_native_webgpu_texture_get_dimension(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_bind_group_reference(const struct CanvasGPUBindGroup *bind_group);
 
-struct CanvasGPUTextureFormat canvas_native_webgpu_texture_get_format(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_bind_group_release(const struct CanvasGPUBindGroup *bind_group);
 
-uint32_t canvas_native_webgpu_texture_get_usage(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_bind_group_layout_reference(const struct CanvasGPUBindGroupLayout *bind_group_layout);
 
-char *canvas_native_webgpu_texture_get_label(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_bind_group_layout_release(const struct CanvasGPUBindGroupLayout *bind_group_layout);
 
-uint32_t canvas_native_webgpu_texture_get_mip_level_count(struct CanvasGPUTexture *texture);
+const struct CanvasGPUBindGroupLayout *canvas_native_webgpu_render_pipeline_get_bind_group_layout(const struct CanvasGPURenderPipeline *pipeline,
+                                                                                                  uint32_t index);
 
-uint32_t canvas_native_webgpu_texture_get_sample_count(struct CanvasGPUTexture *texture);
+enum CanvasGPUErrorType canvas_native_webgpu_error_get_type(const struct CanvasGPUError *error);
 
-char *canvas_native_webgpu_texture_destroy(struct CanvasGPUTexture *texture);
+char *canvas_native_webgpu_error_get_message(const struct CanvasGPUError *error);
 
-struct CanvasGPUBindGroupLayout *canvas_native_webgpu_render_pipeline_get_bind_group_layout(const struct CanvasGPURenderPipeline *pipeline,
-                                                                                            uint32_t index);
+const struct CanvasGPUBindGroupLayout *canvas_native_webgpu_compute_pipeline_get_bind_group_layout(const struct CanvasGPUComputePipeline *pipeline,
+                                                                                                   uint32_t index);
 
 const uint8_t *canvas_native_u8_buffer_get_bytes(const struct U8Buffer *buffer);
 
diff --git a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/_CodeSignature/CodeResources b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/_CodeSignature/CodeResources
index 8fd98f5f3..a56ebf71d 100644
--- a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/_CodeSignature/CodeResources
+++ b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/_CodeSignature/CodeResources
@@ -18,7 +18,7 @@
 		</data>
 		<key>Headers/canvas_native.h</key>
 		<data>
-		TgmoImH8H+2vDVVqe5bZeCt257c=
+		oh8BcSzpm+fp13rGJCaq0GPcTKc=
 		</data>
 		<key>Info.plist</key>
 		<data>
@@ -108,7 +108,7 @@
 		<dict>
 			<key>hash2</key>
 			<data>
-			FkM9f7fdufB6qW4q5CKhNyucqWULq3Zrsp4r2SmSsQg=
+			z6RPJP7ghdTILM/o+hbRJFkhqlzQCpSD5uQEfFdsdOo=
 			</data>
 		</dict>
 		<key>Modules/CanvasNative.swiftmodule/Project/arm64-apple-ios-simulator.swiftsourceinfo</key>
diff --git a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative
index ee02dc918..e4072665b 100644
Binary files a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative and b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative differ
diff --git a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/Relocations/aarch64/CanvasNative.yml b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/Relocations/aarch64/CanvasNative.yml
index b58a94329..3e8bf013e 100644
--- a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/Relocations/aarch64/CanvasNative.yml
+++ b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/Relocations/aarch64/CanvasNative.yml
@@ -2,608 +2,608 @@
 triple:          'arm64-apple-darwin'
 binary-path:     '/Users/triniwiz/Documents/GitHub/canvas/packages/canvas/src-native/canvas-ios/dist/Release-iphonesimulator/CanvasNative.framework/CanvasNative'
 relocations:
-  - { offsetInCU: 0x34, offset: 0x7768C, size: 0x8, addend: 0x0, symName: _CanvasNativeVersionString, symObjAddr: 0x0, symBinAddr: 0x8DD000, symSize: 0x0 }
-  - { offsetInCU: 0x69, offset: 0x776C1, size: 0x8, addend: 0x0, symName: _CanvasNativeVersionNumber, symObjAddr: 0x38, symBinAddr: 0x8DD038, symSize: 0x0 }
-  - { offsetInCU: 0x3F, offset: 0x77716, size: 0x8, addend: 0x0, symName: ___swift_memcpy16_8, symObjAddr: 0x28, symBinAddr: 0x5128, symSize: 0xC }
-  - { offsetInCU: 0x53, offset: 0x7772A, size: 0x8, addend: 0x0, symName: ___swift_noop_void_return, symObjAddr: 0x34, symBinAddr: 0x5134, symSize: 0x4 }
-  - { offsetInCU: 0x67, offset: 0x7773E, size: 0x8, addend: 0x0, symName: '_$sSo6CGSizeVwet', symObjAddr: 0x38, symBinAddr: 0x5138, symSize: 0x20 }
-  - { offsetInCU: 0x7B, offset: 0x77752, size: 0x8, addend: 0x0, symName: '_$sSo6CGSizeVwst', symObjAddr: 0x58, symBinAddr: 0x5158, symSize: 0x28 }
-  - { offsetInCU: 0x8F, offset: 0x77766, size: 0x8, addend: 0x0, symName: '_$sSo6CGRectVwCP', symObjAddr: 0x94, symBinAddr: 0x5194, symSize: 0x30 }
-  - { offsetInCU: 0xA3, offset: 0x7777A, size: 0x8, addend: 0x0, symName: ___swift_memcpy32_8, symObjAddr: 0xC4, symBinAddr: 0x51C4, symSize: 0xC }
-  - { offsetInCU: 0xB7, offset: 0x7778E, size: 0x8, addend: 0x0, symName: '_$sSo6CGRectVwet', symObjAddr: 0xD0, symBinAddr: 0x51D0, symSize: 0x20 }
-  - { offsetInCU: 0xCB, offset: 0x777A2, size: 0x8, addend: 0x0, symName: '_$sSo6CGRectVwst', symObjAddr: 0xF0, symBinAddr: 0x51F0, symSize: 0x2C }
-  - { offsetInCU: 0x4F, offset: 0x7798B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC11_WriteQueue33_05178D28796EA758448493B56DC45144LLSo011NSOperationE0CSgvpZ', symObjAddr: 0x2AE8, symBinAddr: 0x10C3D00, symSize: 0x0 }
-  - { offsetInCU: 0x69, offset: 0x779A5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10_ReadQueue33_05178D28796EA758448493B56DC45144LLSo011NSOperationE0CSgvpZ', symObjAddr: 0x2AF0, symBinAddr: 0x10C3D08, symSize: 0x0 }
-  - { offsetInCU: 0x9D, offset: 0x779D9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC19getBytesFromUIImageySo13NSMutableDataCSo0G0CFZTo', symObjAddr: 0x4, symBinAddr: 0x5294, symSize: 0x38 }
-  - { offsetInCU: 0xF3, offset: 0x77A2F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13createPatternys5Int64VAF_So7UIImageCSStFZTo', symObjAddr: 0x40, symBinAddr: 0x52D0, symSize: 0x70 }
-  - { offsetInCU: 0x144, offset: 0x77A80, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC25loadImageAssetWithContextySbs5Int64V_So7UIImageCtFZTo', symObjAddr: 0xB4, symBinAddr: 0x5344, symSize: 0x44 }
-  - { offsetInCU: 0x19F, offset: 0x77ADB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dyys5Int64V_So7UIImageCS2ftFZTo', symObjAddr: 0xFC, symBinAddr: 0x538C, symSize: 0x50 }
-  - { offsetInCU: 0x204, offset: 0x77B40, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dy2dw2dhys5Int64V_So7UIImageCS4ftFZTo', symObjAddr: 0x150, symBinAddr: 0x53E0, symSize: 0x68 }
-  - { offsetInCU: 0x27D, offset: 0x77BB9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2sx2sy2sw2sh2dx2dy2dw2dhys5Int64V_So7UIImageCS8ftFZTo', symObjAddr: 0x1BC, symBinAddr: 0x544C, symSize: 0x98 }
-  - { offsetInCU: 0x2DA, offset: 0x77C16, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23initWebGPUWithViewLayerys5Int64VAF_AFs6UInt32VAHtFZTo', symObjAddr: 0x258, symBinAddr: 0x54E8, symSize: 0x14 }
-  - { offsetInCU: 0x35C, offset: 0x77C98, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC18initWebGPUWithViewys5Int64VAF_AFs6UInt32VAHtFZTo', symObjAddr: 0x270, symBinAddr: 0x5500, symSize: 0x14 }
-  - { offsetInCU: 0x40B, offset: 0x77D47, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14initGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbtFZTo', symObjAddr: 0x2C8, symBinAddr: 0x5558, symSize: 0x50 }
-  - { offsetInCU: 0x4DC, offset: 0x77E18, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC20initSharedGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbAFtFZTo', symObjAddr: 0x364, symBinAddr: 0x55F4, symSize: 0x58 }
-  - { offsetInCU: 0x5B6, offset: 0x77EF2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC24initGLWithWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbtFZTo', symObjAddr: 0x404, symBinAddr: 0x5694, symSize: 0x58 }
-  - { offsetInCU: 0x695, offset: 0x77FD1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC26initSharedGLWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbAFtFZTo', symObjAddr: 0x4AC, symBinAddr: 0x573C, symSize: 0x60 }
-  - { offsetInCU: 0x741, offset: 0x7807D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15resize2DContextyys5Int64V_S2ftFZTo', symObjAddr: 0x510, symBinAddr: 0x57A0, symSize: 0x8 }
-  - { offsetInCU: 0x7AA, offset: 0x780E6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14flush2DContextyys5Int64VFZTo', symObjAddr: 0x51C, symBinAddr: 0x57AC, symSize: 0x8 }
-  - { offsetInCU: 0x801, offset: 0x7813D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC7flushGLySbs5Int64VFZTo', symObjAddr: 0x538, symBinAddr: 0x57C8, symSize: 0x8 }
-  - { offsetInCU: 0x858, offset: 0x78194, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9releaseGLyys5Int64VFZTo', symObjAddr: 0x544, symBinAddr: 0x57D4, symSize: 0x8 }
-  - { offsetInCU: 0x8AF, offset: 0x781EB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC12getGLPointerys5Int64VAFFZTo', symObjAddr: 0x550, symBinAddr: 0x57E0, symSize: 0x8 }
-  - { offsetInCU: 0x906, offset: 0x78242, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC16releaseGLPointeryys5Int64VFZTo', symObjAddr: 0x55C, symBinAddr: 0x57EC, symSize: 0x8 }
-  - { offsetInCU: 0x985, offset: 0x782C1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15create2DContextys5Int64VAF_s5Int32VAHSbSfA2HSfAHtFZTo', symObjAddr: 0x56C, symBinAddr: 0x57FC, symSize: 0x24 }
-  - { offsetInCU: 0xA36, offset: 0x78372, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23updateGLSurfaceWithViewyys5Int64V_s5Int32VAhFtFZTo', symObjAddr: 0x594, symBinAddr: 0x5824, symSize: 0x14 }
-  - { offsetInCU: 0xAA9, offset: 0x783E5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC6test2Dyys5Int64VFZTo', symObjAddr: 0x5AC, symBinAddr: 0x583C, symSize: 0x8 }
-  - { offsetInCU: 0xB00, offset: 0x7843C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13testToDataURLySSs5Int64VFZTo', symObjAddr: 0x60C, symBinAddr: 0x589C, symSize: 0x74 }
-  - { offsetInCU: 0xB8B, offset: 0x784C7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZTo', symObjAddr: 0x814, symBinAddr: 0x5AA4, symSize: 0xA0 }
-  - { offsetInCU: 0xBDC, offset: 0x78518, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZTo', symObjAddr: 0xB1C, symBinAddr: 0x5DAC, symSize: 0x98 }
-  - { offsetInCU: 0xC2D, offset: 0x78569, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZTo', symObjAddr: 0xE70, symBinAddr: 0x6100, symSize: 0x98 }
-  - { offsetInCU: 0xC89, offset: 0x785C5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZTo', symObjAddr: 0x1298, symBinAddr: 0x6528, symSize: 0xD8 }
-  - { offsetInCU: 0xCD1, offset: 0x7860D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC32getPixelsPerInchForCurrentDeviceSSyFZTo', symObjAddr: 0x1374, symBinAddr: 0x6604, symSize: 0x34 }
-  - { offsetInCU: 0xD31, offset: 0x7866D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCACycfcTo', symObjAddr: 0x13F8, symBinAddr: 0x6688, symSize: 0x3C }
-  - { offsetInCU: 0xD82, offset: 0x786BE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC19getBytesFromUIImageySo13NSMutableDataCSo0G0CFZTf4nd_n', symObjAddr: 0x1468, symBinAddr: 0x66F8, symSize: 0x2AC }
-  - { offsetInCU: 0xFB6, offset: 0x788F2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13createPatternys5Int64VAF_So7UIImageCSStFZTf4nnnd_n', symObjAddr: 0x1714, symBinAddr: 0x69A4, symSize: 0x264 }
-  - { offsetInCU: 0x11B0, offset: 0x78AEC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC25loadImageAssetWithContextySbs5Int64V_So7UIImageCtFZTf4nnd_n', symObjAddr: 0x1978, symBinAddr: 0x6C08, symSize: 0xEC }
-  - { offsetInCU: 0x12AD, offset: 0x78BE9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dyys5Int64V_So7UIImageCS2ftFZTf4nnnnd_n', symObjAddr: 0x1A64, symBinAddr: 0x6CF4, symSize: 0x1B4 }
-  - { offsetInCU: 0x1422, offset: 0x78D5E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dy2dw2dhys5Int64V_So7UIImageCS4ftFZTf4nnnnnnd_n', symObjAddr: 0x1C18, symBinAddr: 0x6EA8, symSize: 0x1CC }
-  - { offsetInCU: 0x15B7, offset: 0x78EF3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2sx2sy2sw2sh2dx2dy2dw2dhys5Int64V_So7UIImageCS8ftFZTf4nnnnnnnnnnd_n', symObjAddr: 0x1DE4, symBinAddr: 0x7074, symSize: 0x1E0 }
-  - { offsetInCU: 0x17A3, offset: 0x790DF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZTf4nnnd_n', symObjAddr: 0x1FC4, symBinAddr: 0x7254, symSize: 0x1B4 }
-  - { offsetInCU: 0x186D, offset: 0x791A9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZTf4nnnnd_n', symObjAddr: 0x231C, symBinAddr: 0x75AC, symSize: 0x1D4 }
-  - { offsetInCU: 0x194E, offset: 0x7928A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC32getPixelsPerInchForCurrentDeviceSSyFZTf4d_n', symObjAddr: 0x24F0, symBinAddr: 0x7780, symSize: 0x114 }
-  - { offsetInCU: 0x19F9, offset: 0x79335, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgACIeyByy_SSSgADIeggg_TR', symObjAddr: 0x8B4, symBinAddr: 0x5B44, symSize: 0x78 }
-  - { offsetInCU: 0x1A11, offset: 0x7934D, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgSo6NSDataCSgIeyByy_SSSgAFIeggg_TR', symObjAddr: 0xBB4, symBinAddr: 0x5E44, symSize: 0x54 }
-  - { offsetInCU: 0x1A7E, offset: 0x793BA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCfETo', symObjAddr: 0x1464, symBinAddr: 0x66F4, symSize: 0x4 }
-  - { offsetInCU: 0x1B09, offset: 0x79445, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCMa', symObjAddr: 0x2604, symBinAddr: 0x7894, symSize: 0x20 }
-  - { offsetInCU: 0x1B1D, offset: 0x79459, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgACIeyByy_SSSgADIeggg_TRTA', symObjAddr: 0x2648, symBinAddr: 0x78D8, symSize: 0x8 }
-  - { offsetInCU: 0x1B3C, offset: 0x79478, size: 0x8, addend: 0x0, symName: '_$sSo7NSErrorCSg10ObjectiveC8ObjCBoolVIeyByy_ACSbIeggy_TRTA', symObjAddr: 0x2650, symBinAddr: 0x78E0, symSize: 0x18 }
-  - { offsetInCU: 0x1B65, offset: 0x794A1, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgSo6NSDataCSgIeyByy_SSSgAFIeggg_TRTA', symObjAddr: 0x2668, symBinAddr: 0x78F8, symSize: 0x8 }
-  - { offsetInCU: 0x1B79, offset: 0x794B5, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCMa', symObjAddr: 0x2670, symBinAddr: 0x7900, symSize: 0x3C }
-  - { offsetInCU: 0x1B8D, offset: 0x794C9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZyyYbcfU_TA', symObjAddr: 0x26F0, symBinAddr: 0x7980, symSize: 0x34 }
-  - { offsetInCU: 0x1BA1, offset: 0x794DD, size: 0x8, addend: 0x0, symName: _block_copy_helper, symObjAddr: 0x2724, symBinAddr: 0x79B4, symSize: 0x10 }
-  - { offsetInCU: 0x1BB5, offset: 0x794F1, size: 0x8, addend: 0x0, symName: _block_destroy_helper, symObjAddr: 0x2734, symBinAddr: 0x79C4, symSize: 0x8 }
-  - { offsetInCU: 0x1BC9, offset: 0x79505, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZyyYbcfU_yyYbcfU0_TA', symObjAddr: 0x2760, symBinAddr: 0x79F0, symSize: 0x40 }
-  - { offsetInCU: 0x1BFD, offset: 0x79539, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZyyYbcfU_yyYbcfU0_TA', symObjAddr: 0x27E4, symBinAddr: 0x7A74, symSize: 0x40 }
-  - { offsetInCU: 0x1C3B, offset: 0x79577, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZyyYbcfU_yyYbcfU_TA', symObjAddr: 0x2824, symBinAddr: 0x7AB4, symSize: 0x28 }
-  - { offsetInCU: 0x1C6F, offset: 0x795AB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZyyYbcfU_yyYbcfU_TA', symObjAddr: 0x28A4, symBinAddr: 0x7B34, symSize: 0x3C }
-  - { offsetInCU: 0x1CA3, offset: 0x795DF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZyyYbcfU_yyYbcfU0_TA', symObjAddr: 0x290C, symBinAddr: 0x7B9C, symSize: 0x30 }
-  - { offsetInCU: 0x1CDF, offset: 0x7961B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZyyYbcfU_TA', symObjAddr: 0x2978, symBinAddr: 0x7C08, symSize: 0x10 }
-  - { offsetInCU: 0x1CF3, offset: 0x7962F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZyyYbcfU_yyYbcfU_TA', symObjAddr: 0x2988, symBinAddr: 0x7C18, symSize: 0x40 }
-  - { offsetInCU: 0x21C0, offset: 0x79AFC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC19getBytesFromUIImageySo13NSMutableDataCSo0G0CFZ', symObjAddr: 0x0, symBinAddr: 0x5290, symSize: 0x4 }
-  - { offsetInCU: 0x21DB, offset: 0x79B17, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x3C, symBinAddr: 0x52CC, symSize: 0x4 }
-  - { offsetInCU: 0x21F6, offset: 0x79B32, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC25loadImageAssetWithContextySbs5Int64V_So7UIImageCtFZ', symObjAddr: 0xB0, symBinAddr: 0x5340, symSize: 0x4 }
-  - { offsetInCU: 0x2217, offset: 0x79B53, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dyys5Int64V_So7UIImageCS2ftFZ', symObjAddr: 0xF8, symBinAddr: 0x5388, symSize: 0x4 }
-  - { offsetInCU: 0x2232, offset: 0x79B6E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dy2dw2dhys5Int64V_So7UIImageCS4ftFZ', symObjAddr: 0x14C, symBinAddr: 0x53DC, symSize: 0x4 }
-  - { offsetInCU: 0x224D, offset: 0x79B89, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2sx2sy2sw2sh2dx2dy2dw2dhys5Int64V_So7UIImageCS8ftFZ', symObjAddr: 0x1B8, symBinAddr: 0x5448, symSize: 0x4 }
-  - { offsetInCU: 0x2268, offset: 0x79BA4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23initWebGPUWithViewLayerys5Int64VAF_AFs6UInt32VAHtFZ', symObjAddr: 0x254, symBinAddr: 0x54E4, symSize: 0x4 }
-  - { offsetInCU: 0x22F6, offset: 0x79C32, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC18initWebGPUWithViewys5Int64VAF_AFs6UInt32VAHtFZ', symObjAddr: 0x26C, symBinAddr: 0x54FC, symSize: 0x4 }
-  - { offsetInCU: 0x2375, offset: 0x79CB1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14initGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbtFZ', symObjAddr: 0x284, symBinAddr: 0x5514, symSize: 0x44 }
-  - { offsetInCU: 0x24B3, offset: 0x79DEF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC20initSharedGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbAFtFZ', symObjAddr: 0x318, symBinAddr: 0x55A8, symSize: 0x4C }
-  - { offsetInCU: 0x25FC, offset: 0x79F38, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC24initGLWithWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbtFZ', symObjAddr: 0x3BC, symBinAddr: 0x564C, symSize: 0x48 }
-  - { offsetInCU: 0x2744, offset: 0x7A080, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC26initSharedGLWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbAFtFZ', symObjAddr: 0x45C, symBinAddr: 0x56EC, symSize: 0x50 }
-  - { offsetInCU: 0x28A1, offset: 0x7A1DD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15resize2DContextyys5Int64V_S2ftFZ', symObjAddr: 0x50C, symBinAddr: 0x579C, symSize: 0x4 }
-  - { offsetInCU: 0x2913, offset: 0x7A24F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14flush2DContextyys5Int64VFZ', symObjAddr: 0x518, symBinAddr: 0x57A8, symSize: 0x4 }
-  - { offsetInCU: 0x2956, offset: 0x7A292, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC7flushGLySbs5Int64VFZ', symObjAddr: 0x524, symBinAddr: 0x57B4, symSize: 0x14 }
-  - { offsetInCU: 0x299B, offset: 0x7A2D7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9releaseGLyys5Int64VFZ', symObjAddr: 0x540, symBinAddr: 0x57D0, symSize: 0x4 }
-  - { offsetInCU: 0x29DE, offset: 0x7A31A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC12getGLPointerys5Int64VAFFZ', symObjAddr: 0x54C, symBinAddr: 0x57DC, symSize: 0x4 }
-  - { offsetInCU: 0x2A21, offset: 0x7A35D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC16releaseGLPointeryys5Int64VFZ', symObjAddr: 0x558, symBinAddr: 0x57E8, symSize: 0x4 }
-  - { offsetInCU: 0x2A64, offset: 0x7A3A0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15create2DContextys5Int64VAF_s5Int32VAHSbSfA2HSfAHtFZ', symObjAddr: 0x564, symBinAddr: 0x57F4, symSize: 0x8 }
-  - { offsetInCU: 0x2B4B, offset: 0x7A487, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23updateGLSurfaceWithViewyys5Int64V_s5Int32VAhFtFZ', symObjAddr: 0x590, symBinAddr: 0x5820, symSize: 0x4 }
-  - { offsetInCU: 0x2BCA, offset: 0x7A506, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC6test2Dyys5Int64VFZ', symObjAddr: 0x5A8, symBinAddr: 0x5838, symSize: 0x4 }
-  - { offsetInCU: 0x2C0D, offset: 0x7A549, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13testToDataURLySSs5Int64VFZ', symObjAddr: 0x5B4, symBinAddr: 0x5844, symSize: 0x58 }
-  - { offsetInCU: 0x2CCE, offset: 0x7A60A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZ', symObjAddr: 0x680, symBinAddr: 0x5910, symSize: 0x4 }
-  - { offsetInCU: 0x2CE2, offset: 0x7A61E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZyyYbcfU_', symObjAddr: 0x684, symBinAddr: 0x5914, symSize: 0x190 }
-  - { offsetInCU: 0x2D82, offset: 0x7A6BE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZ', symObjAddr: 0x92C, symBinAddr: 0x5BBC, symSize: 0x2C }
-  - { offsetInCU: 0x2D96, offset: 0x7A6D2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZyyYbcfU_', symObjAddr: 0x958, symBinAddr: 0x5BE8, symSize: 0x1C4 }
-  - { offsetInCU: 0x2E80, offset: 0x7A7BC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZ', symObjAddr: 0xC08, symBinAddr: 0x5E98, symSize: 0x2C }
-  - { offsetInCU: 0x2E94, offset: 0x7A7D0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZyyYbcfU_', symObjAddr: 0xC34, symBinAddr: 0x5EC4, symSize: 0x23C }
-  - { offsetInCU: 0x2F48, offset: 0x7A884, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZ', symObjAddr: 0xF08, symBinAddr: 0x6198, symSize: 0x4 }
-  - { offsetInCU: 0x2F5C, offset: 0x7A898, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZyyYbcfU_', symObjAddr: 0xF0C, symBinAddr: 0x619C, symSize: 0x38C }
-  - { offsetInCU: 0x31F3, offset: 0x7AB2F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC32getPixelsPerInchForCurrentDeviceSSyFZ', symObjAddr: 0x1370, symBinAddr: 0x6600, symSize: 0x4 }
-  - { offsetInCU: 0x320E, offset: 0x7AB4A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCACycfC', symObjAddr: 0x13A8, symBinAddr: 0x6638, symSize: 0x20 }
-  - { offsetInCU: 0x3222, offset: 0x7AB5E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCACycfc', symObjAddr: 0x13C8, symBinAddr: 0x6658, symSize: 0x30 }
-  - { offsetInCU: 0x3258, offset: 0x7AB94, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCfD', symObjAddr: 0x1434, symBinAddr: 0x66C4, symSize: 0x30 }
-  - { offsetInCU: 0x4F, offset: 0x7ADCC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19shared_context_view33_508084857CA7D194CA72FEB80DD78002LLSo7GLKViewCvpZ', symObjAddr: 0x55B0, symBinAddr: 0x10C3D40, symSize: 0x0 }
-  - { offsetInCU: 0x69, offset: 0x7ADE6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15_shared_context33_508084857CA7D194CA72FEB80DD78002LLs5Int64VvpZ', symObjAddr: 0x55B8, symBinAddr: 0x10C3D48, symSize: 0x0 }
-  - { offsetInCU: 0x83, offset: 0x7AE00, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5storeSo19NSMutableDictionaryCvpZ', symObjAddr: 0x55C0, symBinAddr: 0x10C3D50, symSize: 0x0 }
-  - { offsetInCU: 0x9D, offset: 0x7AE1A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5views33_508084857CA7D194CA72FEB80DD78002LLSo10NSMapTableCySo8NSStringCACGvpZ', symObjAddr: 0x55C8, symBinAddr: 0x10C3D58, symSize: 0x0 }
-  - { offsetInCU: 0xAB, offset: 0x7AE28, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19shared_context_view33_508084857CA7D194CA72FEB80DD78002LL_WZ', symObjAddr: 0x0, symBinAddr: 0x7D40, symSize: 0x40 }
-  - { offsetInCU: 0xF0, offset: 0x7AE6D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5store_WZ', symObjAddr: 0x40, symBinAddr: 0x7D80, symSize: 0x30 }
-  - { offsetInCU: 0x135, offset: 0x7AEB2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5views33_508084857CA7D194CA72FEB80DD78002LL_WZ', symObjAddr: 0xA8, symBinAddr: 0x7DE8, symSize: 0x40 }
-  - { offsetInCU: 0x187, offset: 0x7AF04, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC3ptrSvSgvgTo', symObjAddr: 0x194, symBinAddr: 0x7ED4, symSize: 0x10 }
-  - { offsetInCU: 0x1A7, offset: 0x7AF24, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC3ptrSvSgvgTo', symObjAddr: 0x194, symBinAddr: 0x7ED4, symSize: 0x10 }
-  - { offsetInCU: 0x1DD, offset: 0x7AF5A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC3ptrSvSgvsTo', symObjAddr: 0x1A4, symBinAddr: 0x7EE4, symSize: 0x10 }
-  - { offsetInCU: 0x1FD, offset: 0x7AF7A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC3ptrSvSgvsTo', symObjAddr: 0x1A4, symBinAddr: 0x7EE4, symSize: 0x10 }
-  - { offsetInCU: 0x236, offset: 0x7AFB3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6mtlPtrSvSgvgTo', symObjAddr: 0x1B4, symBinAddr: 0x7EF4, symSize: 0x10 }
-  - { offsetInCU: 0x256, offset: 0x7AFD3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6mtlPtrSvSgvgTo', symObjAddr: 0x1B4, symBinAddr: 0x7EF4, symSize: 0x10 }
-  - { offsetInCU: 0x28C, offset: 0x7B009, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6mtlPtrSvSgvsTo', symObjAddr: 0x1C4, symBinAddr: 0x7F04, symSize: 0x10 }
-  - { offsetInCU: 0x2AC, offset: 0x7B029, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6mtlPtrSvSgvsTo', symObjAddr: 0x1C4, symBinAddr: 0x7F04, symSize: 0x10 }
-  - { offsetInCU: 0x2E5, offset: 0x7B062, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvgTo', symObjAddr: 0x29C, symBinAddr: 0x7FDC, symSize: 0x44 }
-  - { offsetInCU: 0x322, offset: 0x7B09F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvsTo', symObjAddr: 0x324, symBinAddr: 0x8064, symSize: 0x30 }
-  - { offsetInCU: 0x3B1, offset: 0x7B12E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8nativeGLs5Int64VvgTo', symObjAddr: 0x578, symBinAddr: 0x82B8, symSize: 0x44 }
-  - { offsetInCU: 0x409, offset: 0x7B186, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8nativeGLs5Int64VvsTo', symObjAddr: 0x600, symBinAddr: 0x8340, symSize: 0x48 }
-  - { offsetInCU: 0x464, offset: 0x7B1E1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13nativeContexts5Int64VvgTo', symObjAddr: 0x648, symBinAddr: 0x8388, symSize: 0x44 }
-  - { offsetInCU: 0x4BC, offset: 0x7B239, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13nativeContexts5Int64VvsTo', symObjAddr: 0x6D0, symBinAddr: 0x8410, symSize: 0x48 }
-  - { offsetInCU: 0x517, offset: 0x7B294, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15native2DContexts5Int64VvgTo', symObjAddr: 0x718, symBinAddr: 0x8458, symSize: 0x10 }
-  - { offsetInCU: 0x537, offset: 0x7B2B4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15native2DContexts5Int64VvgTo', symObjAddr: 0x718, symBinAddr: 0x8458, symSize: 0x10 }
-  - { offsetInCU: 0x56D, offset: 0x7B2EA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15native2DContexts5Int64VvsTo', symObjAddr: 0x728, symBinAddr: 0x8468, symSize: 0x10 }
-  - { offsetInCU: 0x58D, offset: 0x7B30A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15native2DContexts5Int64VvsTo', symObjAddr: 0x728, symBinAddr: 0x8468, symSize: 0x10 }
-  - { offsetInCU: 0x5C6, offset: 0x7B343, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7mtlViewSo7MTKViewCvgTo', symObjAddr: 0x738, symBinAddr: 0x8478, symSize: 0x10 }
-  - { offsetInCU: 0x5E6, offset: 0x7B363, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7mtlViewSo7MTKViewCvgTo', symObjAddr: 0x738, symBinAddr: 0x8478, symSize: 0x10 }
-  - { offsetInCU: 0x61E, offset: 0x7B39B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7mtlViewSo7MTKViewCvsTo', symObjAddr: 0x748, symBinAddr: 0x8488, symSize: 0x34 }
-  - { offsetInCU: 0x677, offset: 0x7B3F4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7glkViewAA0A7GLKViewCvgTo', symObjAddr: 0x77C, symBinAddr: 0x84BC, symSize: 0x10 }
-  - { offsetInCU: 0x697, offset: 0x7B414, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7glkViewAA0A7GLKViewCvgTo', symObjAddr: 0x77C, symBinAddr: 0x84BC, symSize: 0x10 }
-  - { offsetInCU: 0x6CF, offset: 0x7B44C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7glkViewAA0A7GLKViewCvsTo', symObjAddr: 0x78C, symBinAddr: 0x84CC, symSize: 0x34 }
-  - { offsetInCU: 0x728, offset: 0x7B4A5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC4is2DSbvgTo', symObjAddr: 0x7C0, symBinAddr: 0x8500, symSize: 0x10 }
-  - { offsetInCU: 0x748, offset: 0x7B4C5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC4is2DSbvgTo', symObjAddr: 0x7C0, symBinAddr: 0x8500, symSize: 0x10 }
-  - { offsetInCU: 0x77E, offset: 0x7B4FB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC4is2DSbvsTo', symObjAddr: 0x7D0, symBinAddr: 0x8510, symSize: 0x10 }
-  - { offsetInCU: 0x79E, offset: 0x7B51B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC4is2DSbvsTo', symObjAddr: 0x7D0, symBinAddr: 0x8510, symSize: 0x10 }
-  - { offsetInCU: 0x7D7, offset: 0x7B554, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7isMetalSbvgTo', symObjAddr: 0x7E0, symBinAddr: 0x8520, symSize: 0x10 }
-  - { offsetInCU: 0x7F7, offset: 0x7B574, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7isMetalSbvgTo', symObjAddr: 0x7E0, symBinAddr: 0x8520, symSize: 0x10 }
-  - { offsetInCU: 0x82D, offset: 0x7B5AA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7isMetalSbvsTo', symObjAddr: 0x7F0, symBinAddr: 0x8530, symSize: 0x10 }
-  - { offsetInCU: 0x84D, offset: 0x7B5CA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7isMetalSbvsTo', symObjAddr: 0x7F0, symBinAddr: 0x8530, symSize: 0x10 }
-  - { offsetInCU: 0x870, offset: 0x7B5ED, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18drawingBufferWidthSivgTo', symObjAddr: 0x800, symBinAddr: 0x8540, symSize: 0x34 }
-  - { offsetInCU: 0x8A2, offset: 0x7B61F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19drawingBufferHeightSivgTo', symObjAddr: 0x904, symBinAddr: 0x8644, symSize: 0x34 }
-  - { offsetInCU: 0x8EA, offset: 0x7B667, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5widthSfvgTo', symObjAddr: 0xA08, symBinAddr: 0x8748, symSize: 0x20 }
-  - { offsetInCU: 0x952, offset: 0x7B6CF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6heightSfvgTo', symObjAddr: 0xA4C, symBinAddr: 0x878C, symSize: 0x20 }
-  - { offsetInCU: 0x9F1, offset: 0x7B76E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11initContextyySS_S4bs5Int32VS5btFTo', symObjAddr: 0xAB4, symBinAddr: 0x87F4, symSize: 0xC4 }
-  - { offsetInCU: 0xAB4, offset: 0x7B831, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17initWebGPUContextyys5Int64VFTo', symObjAddr: 0xD10, symBinAddr: 0x8A50, symSize: 0x30 }
-  - { offsetInCU: 0xB64, offset: 0x7B8E1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC015initContextWithE10AttributesyySS_S4bs5Int32VS5btFTo', symObjAddr: 0x15B0, symBinAddr: 0x92F0, symSize: 0xC4 }
-  - { offsetInCU: 0xBCE, offset: 0x7B94B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15create2DContextys5Int64VSb_S3bs5Int32VS5bAHtFTo', symObjAddr: 0x18CC, symBinAddr: 0x960C, symSize: 0xB0 }
-  - { offsetInCU: 0xC0B, offset: 0x7B988, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11forceLayoutyy12CoreGraphics7CGFloatV_AGtFTo', symObjAddr: 0x1A3C, symBinAddr: 0x977C, symSize: 0xB8 }
-  - { offsetInCU: 0xC83, offset: 0x7BA00, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8snapshotySo7UIImageCSgSbFTo', symObjAddr: 0x1BD8, symBinAddr: 0x9918, symSize: 0x3C }
-  - { offsetInCU: 0xCB6, offset: 0x7BA33, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8rendererAA9NSCRenderCSgvgTo', symObjAddr: 0x1C14, symBinAddr: 0x9954, symSize: 0x10 }
-  - { offsetInCU: 0xCD6, offset: 0x7BA53, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8rendererAA9NSCRenderCSgvgTo', symObjAddr: 0x1C14, symBinAddr: 0x9954, symSize: 0x10 }
-  - { offsetInCU: 0xD10, offset: 0x7BA8D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8rendererAA9NSCRenderCSgvsTo', symObjAddr: 0x1C24, symBinAddr: 0x9964, symSize: 0x34 }
-  - { offsetInCU: 0xD6B, offset: 0x7BAE8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6renderSbyFTo', symObjAddr: 0x1CA0, symBinAddr: 0x99E0, symSize: 0x48 }
-  - { offsetInCU: 0xE05, offset: 0x7BB82, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13context2DTestyys5Int64VFTo', symObjAddr: 0x1D34, symBinAddr: 0x9A74, symSize: 0x64 }
-  - { offsetInCU: 0xECA, offset: 0x7BC47, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC22context2DTestToDataURLySSs5Int64VFTo', symObjAddr: 0x1DF0, symBinAddr: 0x9B30, symSize: 0x94 }
-  - { offsetInCU: 0xF57, offset: 0x7BCD4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC23enterBackgroundListeneryycSgvsTo', symObjAddr: 0x1EC4, symBinAddr: 0x9C04, symSize: 0x6C }
-  - { offsetInCU: 0xFB9, offset: 0x7BD36, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC20becomeActiveListeneryycSgvsTo', symObjAddr: 0x1FD4, symBinAddr: 0x9D14, symSize: 0x6C }
-  - { offsetInCU: 0x1016, offset: 0x7BD93, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvgTo', symObjAddr: 0x2040, symBinAddr: 0x9D80, symSize: 0xB0 }
-  - { offsetInCU: 0x1068, offset: 0x7BDE5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvsTo', symObjAddr: 0x21C0, symBinAddr: 0x9F00, symSize: 0x94 }
-  - { offsetInCU: 0x10FA, offset: 0x7BE77, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5coderACSgSo7NSCoderC_tcfcTo', symObjAddr: 0x2EAC, symBinAddr: 0xABEC, symSize: 0x28 }
-  - { offsetInCU: 0x114F, offset: 0x7BECC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5frameACSo6CGRectV_tcfcTo', symObjAddr: 0x392C, symBinAddr: 0xB66C, symSize: 0x20 }
-  - { offsetInCU: 0x1182, offset: 0x7BEFF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvgTo', symObjAddr: 0x394C, symBinAddr: 0xB68C, symSize: 0x10 }
-  - { offsetInCU: 0x11A2, offset: 0x7BF1F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvgTo', symObjAddr: 0x394C, symBinAddr: 0xB68C, symSize: 0x10 }
-  - { offsetInCU: 0x11DA, offset: 0x7BF57, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvsTo', symObjAddr: 0x395C, symBinAddr: 0xB69C, symSize: 0x34 }
-  - { offsetInCU: 0x1248, offset: 0x7BFC5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13readyListenerAA0cE0_pSgvgTo', symObjAddr: 0x3A10, symBinAddr: 0xB750, symSize: 0x20 }
-  - { offsetInCU: 0x12A2, offset: 0x7C01F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13readyListenerAA0cE0_pSgvsTo', symObjAddr: 0x3A30, symBinAddr: 0xB770, symSize: 0x34 }
-  - { offsetInCU: 0x1302, offset: 0x7C07F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11setListeneryyAA0cE0_pSgFTo', symObjAddr: 0x3A94, symBinAddr: 0xB7D4, symSize: 0x34 }
-  - { offsetInCU: 0x1446, offset: 0x7C1C3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC14layoutSubviewsyyFTo', symObjAddr: 0x3DE0, symBinAddr: 0xBB20, symSize: 0x28 }
-  - { offsetInCU: 0x1479, offset: 0x7C1F6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCfDTo', symObjAddr: 0x410C, symBinAddr: 0xBE4C, symSize: 0x24 }
-  - { offsetInCU: 0x14B4, offset: 0x7C231, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC21getBoundingClientRectyySo6UIViewC_SvtFZTo', symObjAddr: 0x41F8, symBinAddr: 0xBF38, symSize: 0x34 }
-  - { offsetInCU: 0x14E7, offset: 0x7C264, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC14shared_context33_508084857CA7D194CA72FEB80DD78002LLs5Int64VvgZTf4d_n', symObjAddr: 0x4B8C, symBinAddr: 0xC8CC, symSize: 0x298 }
-  - { offsetInCU: 0x1664, offset: 0x7C3E1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC21getBoundingClientRectyySo6UIViewC_SvtFZTf4nnd_n', symObjAddr: 0x4EE8, symBinAddr: 0xCC28, symSize: 0xA0 }
-  - { offsetInCU: 0x18E0, offset: 0x7C65D, size: 0x8, addend: 0x0, symName: '_$sIeg_IeyB_TR', symObjAddr: 0x1E98, symBinAddr: 0x9BD8, symSize: 0x2C }
-  - { offsetInCU: 0x18F8, offset: 0x7C675, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_So8NSStringCABIeyByy_TR', symObjAddr: 0x2148, symBinAddr: 0x9E88, symSize: 0x78 }
-  - { offsetInCU: 0x1910, offset: 0x7C68D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvpACTK', symObjAddr: 0x22B0, symBinAddr: 0x9FF0, symSize: 0x94 }
-  - { offsetInCU: 0x1948, offset: 0x7C6C5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvpACTk', symObjAddr: 0x2344, symBinAddr: 0xA084, symSize: 0xB8 }
-  - { offsetInCU: 0x198A, offset: 0x7C707, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCytIegnnr_SSABIeggg_TR', symObjAddr: 0x23FC, symBinAddr: 0xA13C, symSize: 0x6C }
-  - { offsetInCU: 0x1A3A, offset: 0x7C7B7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCfETo', symObjAddr: 0x4130, symBinAddr: 0xBE70, symSize: 0xC4 }
-  - { offsetInCU: 0x1A6A, offset: 0x7C7E7, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_SgWOy', symObjAddr: 0x422C, symBinAddr: 0xBF6C, symSize: 0x10 }
-  - { offsetInCU: 0x1A7E, offset: 0x7C7FB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCMa', symObjAddr: 0x423C, symBinAddr: 0xBF7C, symSize: 0x20 }
-  - { offsetInCU: 0x1A92, offset: 0x7C80F, size: 0x8, addend: 0x0, symName: '_$ss29getContiguousArrayStorageType3fors01_bcD0CyxGmxm_tlFSo18NSLayoutConstraintC_Tgm5', symObjAddr: 0x425C, symBinAddr: 0xBF9C, symSize: 0x64 }
-  - { offsetInCU: 0x1C99, offset: 0x7CA16, size: 0x8, addend: 0x0, symName: ___swift_instantiateConcreteTypeFromMangledName, symObjAddr: 0x4E24, symBinAddr: 0xCB64, symSize: 0x40 }
-  - { offsetInCU: 0x1CAD, offset: 0x7CA2A, size: 0x8, addend: 0x0, symName: '_$sypSgWOh', symObjAddr: 0x4E64, symBinAddr: 0xCBA4, symSize: 0x40 }
-  - { offsetInCU: 0x1CC1, offset: 0x7CA3E, size: 0x8, addend: 0x0, symName: ___swift_project_boxed_opaque_existential_0, symObjAddr: 0x4EA4, symBinAddr: 0xCBE4, symSize: 0x24 }
-  - { offsetInCU: 0x1CD5, offset: 0x7CA52, size: 0x8, addend: 0x0, symName: ___swift_destroy_boxed_opaque_existential_0, symObjAddr: 0x4EC8, symBinAddr: 0xCC08, symSize: 0x20 }
-  - { offsetInCU: 0x1CF4, offset: 0x7CA71, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSo19UIGestureRecognizerCIeyByy_SSADIeggg_TRTA', symObjAddr: 0x53B4, symBinAddr: 0xD0F4, symSize: 0x48 }
-  - { offsetInCU: 0x1D1D, offset: 0x7CA9A, size: 0x8, addend: 0x0, symName: _block_copy_helper, symObjAddr: 0x53FC, symBinAddr: 0xD13C, symSize: 0x10 }
-  - { offsetInCU: 0x1D31, offset: 0x7CAAE, size: 0x8, addend: 0x0, symName: _block_destroy_helper, symObjAddr: 0x540C, symBinAddr: 0xD14C, symSize: 0x8 }
-  - { offsetInCU: 0x1D45, offset: 0x7CAC2, size: 0x8, addend: 0x0, symName: '_$sIeg_SgWOe', symObjAddr: 0x5414, symBinAddr: 0xD154, symSize: 0x10 }
-  - { offsetInCU: 0x1D64, offset: 0x7CAE1, size: 0x8, addend: 0x0, symName: '_$sIeyB_Ieg_TRTA', symObjAddr: 0x5424, symBinAddr: 0xD164, symSize: 0xC }
-  - { offsetInCU: 0x1D8D, offset: 0x7CB0A, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCytIegnnr_SSABIeggg_TRTA', symObjAddr: 0x5454, symBinAddr: 0xD194, symSize: 0x8 }
-  - { offsetInCU: 0x1DAC, offset: 0x7CB29, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_SSABytIegnnr_TRTA', symObjAddr: 0x545C, symBinAddr: 0xD19C, symSize: 0x30 }
-  - { offsetInCU: 0x1DD5, offset: 0x7CB52, size: 0x8, addend: 0x0, symName: '_$sypWOb', symObjAddr: 0x548C, symBinAddr: 0xD1CC, symSize: 0x10 }
-  - { offsetInCU: 0x1DE9, offset: 0x7CB66, size: 0x8, addend: 0x0, symName: '_$sypWOc', symObjAddr: 0x54D4, symBinAddr: 0xD214, symSize: 0x3C }
-  - { offsetInCU: 0x206E, offset: 0x7CDEB, size: 0x8, addend: 0x0, symName: '_$sSD17dictionaryLiteralSDyxq_Gx_q_td_tcfCSS_ypTgm5Tf4g_n', symObjAddr: 0x4A7C, symBinAddr: 0xC7BC, symSize: 0x110 }
-  - { offsetInCU: 0x251C, offset: 0x7D299, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvg', symObjAddr: 0x2E0, symBinAddr: 0x8020, symSize: 0x44 }
-  - { offsetInCU: 0x254F, offset: 0x7D2CC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvs', symObjAddr: 0x354, symBinAddr: 0x8094, symSize: 0xEC }
-  - { offsetInCU: 0x259B, offset: 0x7D318, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvM', symObjAddr: 0x440, symBinAddr: 0x8180, symSize: 0x58 }
-  - { offsetInCU: 0x25C0, offset: 0x7D33D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvM.resume.0', symObjAddr: 0x498, symBinAddr: 0x81D8, symSize: 0xE0 }
-  - { offsetInCU: 0x2601, offset: 0x7D37E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8nativeGLs5Int64Vvg', symObjAddr: 0x5BC, symBinAddr: 0x82FC, symSize: 0x44 }
-  - { offsetInCU: 0x2659, offset: 0x7D3D6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13nativeContexts5Int64Vvg', symObjAddr: 0x68C, symBinAddr: 0x83CC, symSize: 0x44 }
-  - { offsetInCU: 0x27C7, offset: 0x7D544, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18drawingBufferWidthSivg', symObjAddr: 0x834, symBinAddr: 0x8574, symSize: 0xD0 }
-  - { offsetInCU: 0x28EC, offset: 0x7D669, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19drawingBufferHeightSivg', symObjAddr: 0x938, symBinAddr: 0x8678, symSize: 0xD0 }
-  - { offsetInCU: 0x2A32, offset: 0x7D7AF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5widthSfvg', symObjAddr: 0xA28, symBinAddr: 0x8768, symSize: 0x24 }
-  - { offsetInCU: 0x2A7A, offset: 0x7D7F7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6heightSfvg', symObjAddr: 0xA6C, symBinAddr: 0x87AC, symSize: 0x24 }
-  - { offsetInCU: 0x2AAE, offset: 0x7D82B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11initContextyySS_S4bs5Int32VS5btF', symObjAddr: 0xA90, symBinAddr: 0x87D0, symSize: 0x24 }
-  - { offsetInCU: 0x2C3C, offset: 0x7D9B9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17initWebGPUContextyys5Int64VF', symObjAddr: 0xB78, symBinAddr: 0x88B8, symSize: 0x198 }
-  - { offsetInCU: 0x302F, offset: 0x7DDAC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC015initContextWithE10AttributesyySS_S4bs5Int32VS5btF', symObjAddr: 0xD40, symBinAddr: 0x8A80, symSize: 0x870 }
-  - { offsetInCU: 0x3832, offset: 0x7E5AF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15create2DContextys5Int64VSb_S3bs5Int32VS5bAHtF', symObjAddr: 0x1674, symBinAddr: 0x93B4, symSize: 0x258 }
-  - { offsetInCU: 0x3C64, offset: 0x7E9E1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11forceLayoutyy12CoreGraphics7CGFloatV_AGtF', symObjAddr: 0x197C, symBinAddr: 0x96BC, symSize: 0xC0 }
-  - { offsetInCU: 0x3CF5, offset: 0x7EA72, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8snapshotySo7UIImageCSgSbF', symObjAddr: 0x1AF4, symBinAddr: 0x9834, symSize: 0xE4 }
-  - { offsetInCU: 0x3E50, offset: 0x7EBCD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6renderSbyF', symObjAddr: 0x1C58, symBinAddr: 0x9998, symSize: 0x48 }
-  - { offsetInCU: 0x3ED6, offset: 0x7EC53, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13context2DTestyys5Int64VF', symObjAddr: 0x1CE8, symBinAddr: 0x9A28, symSize: 0x4C }
-  - { offsetInCU: 0x3FF7, offset: 0x7ED74, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC22context2DTestToDataURLySSs5Int64VF', symObjAddr: 0x1D98, symBinAddr: 0x9AD8, symSize: 0x58 }
-  - { offsetInCU: 0x40ED, offset: 0x7EE6A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvg', symObjAddr: 0x20F0, symBinAddr: 0x9E30, symSize: 0x58 }
-  - { offsetInCU: 0x4139, offset: 0x7EEB6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvs', symObjAddr: 0x2254, symBinAddr: 0x9F94, symSize: 0x5C }
-  - { offsetInCU: 0x4162, offset: 0x7EEDF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvM', symObjAddr: 0x2468, symBinAddr: 0xA1A8, symSize: 0x44 }
-  - { offsetInCU: 0x4188, offset: 0x7EF05, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvM.resume.0', symObjAddr: 0x24AC, symBinAddr: 0xA1EC, symSize: 0x4 }
-  - { offsetInCU: 0x424A, offset: 0x7EFC7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5coderACSgSo7NSCoderC_tcfc', symObjAddr: 0x24B0, symBinAddr: 0xA1F0, symSize: 0x9FC }
-  - { offsetInCU: 0x446D, offset: 0x7F1EA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5frameACSo6CGRectV_tcfC', symObjAddr: 0x2ED4, symBinAddr: 0xAC14, symSize: 0x50 }
-  - { offsetInCU: 0x4496, offset: 0x7F213, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5frameACSo6CGRectV_tcfc', symObjAddr: 0x2F24, symBinAddr: 0xAC64, symSize: 0xA08 }
-  - { offsetInCU: 0x46DA, offset: 0x7F457, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvW', symObjAddr: 0x3990, symBinAddr: 0xB6D0, symSize: 0x80 }
-  - { offsetInCU: 0x47D0, offset: 0x7F54D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11setListeneryyAA0cE0_pSgF', symObjAddr: 0x3A64, symBinAddr: 0xB7A4, symSize: 0x30 }
-  - { offsetInCU: 0x486E, offset: 0x7F5EB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6resize33_508084857CA7D194CA72FEB80DD78002LLyyF', symObjAddr: 0x3AC8, symBinAddr: 0xB808, symSize: 0x144 }
-  - { offsetInCU: 0x4A6F, offset: 0x7F7EC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC14layoutSubviewsyyF', symObjAddr: 0x3C0C, symBinAddr: 0xB94C, symSize: 0x1D4 }
-  - { offsetInCU: 0x4CEC, offset: 0x7FA69, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCfD', symObjAddr: 0x3E08, symBinAddr: 0xBB48, symSize: 0x304 }
-  - { offsetInCU: 0x4D7C, offset: 0x7FAF9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC21getBoundingClientRectyySo6UIViewC_SvtFZ', symObjAddr: 0x41F4, symBinAddr: 0xBF34, symSize: 0x4 }
-  - { offsetInCU: 0x4DA4, offset: 0x7FB21, size: 0x8, addend: 0x0, symName: '_$ss22__RawDictionaryStorageC4findys10_HashTableV6BucketV6bucket_Sb5foundtxSHRzlFSS_Tg5', symObjAddr: 0x42C0, symBinAddr: 0xC000, symSize: 0x64 }
-  - { offsetInCU: 0x4DFE, offset: 0x7FB7B, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV7_insert2at3key5valueys10_HashTableV6BucketV_xnq_ntFSS_ypTg5', symObjAddr: 0x4324, symBinAddr: 0xC064, symSize: 0x6C }
-  - { offsetInCU: 0x4E7E, offset: 0x7FBFB, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV12mutatingFind_8isUniques10_HashTableV6BucketV6bucket_Sb5foundtx_SbtFSS_ypTg5', symObjAddr: 0x4390, symBinAddr: 0xC0D0, symSize: 0xD8 }
-  - { offsetInCU: 0x4EBB, offset: 0x7FC38, size: 0x8, addend: 0x0, symName: '_$ss22__RawDictionaryStorageC4find_9hashValues10_HashTableV6BucketV6bucket_Sb5foundtx_SitSHRzlFSS_Tg5', symObjAddr: 0x4468, symBinAddr: 0xC1A8, symSize: 0xE0 }
-  - { offsetInCU: 0x4F36, offset: 0x7FCB3, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV4copyyyFSS_ypTg5', symObjAddr: 0x4548, symBinAddr: 0xC288, symSize: 0x1F4 }
-  - { offsetInCU: 0x4FF2, offset: 0x7FD6F, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV20_copyOrMoveAndResize8capacity12moveElementsySi_SbtFSS_ypTg5', symObjAddr: 0x473C, symBinAddr: 0xC47C, symSize: 0x340 }
-  - { offsetInCU: 0x27, offset: 0x7FFD7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative7GLUtilsCfD', symObjAddr: 0x0, symBinAddr: 0xD2B4, symSize: 0x10 }
-  - { offsetInCU: 0x62, offset: 0x80012, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative7GLUtilsCMa', symObjAddr: 0x10, symBinAddr: 0xD2C4, symSize: 0x20 }
-  - { offsetInCU: 0x1AF, offset: 0x8015F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative7GLUtilsCfD', symObjAddr: 0x0, symBinAddr: 0xD2B4, symSize: 0x10 }
-  - { offsetInCU: 0x65, offset: 0x801EE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8mPrograms6UInt32VvgTo', symObjAddr: 0x0, symBinAddr: 0xD2E4, symSize: 0x10 }
-  - { offsetInCU: 0x85, offset: 0x8020E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8mPrograms6UInt32VvgTo', symObjAddr: 0x0, symBinAddr: 0xD2E4, symSize: 0x10 }
-  - { offsetInCU: 0xBB, offset: 0x80244, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8mPrograms6UInt32VvsTo', symObjAddr: 0x10, symBinAddr: 0xD2F4, symSize: 0x10 }
-  - { offsetInCU: 0xDB, offset: 0x80264, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8mPrograms6UInt32VvsTo', symObjAddr: 0x10, symBinAddr: 0xD2F4, symSize: 0x10 }
-  - { offsetInCU: 0x114, offset: 0x8029D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3rbos6UInt32VvgTo', symObjAddr: 0x20, symBinAddr: 0xD304, symSize: 0x44 }
-  - { offsetInCU: 0x16C, offset: 0x802F5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3rbos6UInt32VvsTo', symObjAddr: 0x64, symBinAddr: 0xD348, symSize: 0x48 }
-  - { offsetInCU: 0x1C7, offset: 0x80350, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3fbos6UInt32VvgTo', symObjAddr: 0xAC, symBinAddr: 0xD390, symSize: 0x44 }
-  - { offsetInCU: 0x21F, offset: 0x803A8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3fbos6UInt32VvsTo', symObjAddr: 0xF0, symBinAddr: 0xD3D4, symSize: 0x48 }
-  - { offsetInCU: 0x27A, offset: 0x80403, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC5widthSivgTo', symObjAddr: 0x138, symBinAddr: 0xD41C, symSize: 0x10 }
-  - { offsetInCU: 0x29A, offset: 0x80423, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC5widthSivgTo', symObjAddr: 0x138, symBinAddr: 0xD41C, symSize: 0x10 }
-  - { offsetInCU: 0x2D0, offset: 0x80459, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC5widthSivsTo', symObjAddr: 0x148, symBinAddr: 0xD42C, symSize: 0x10 }
-  - { offsetInCU: 0x2F0, offset: 0x80479, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC5widthSivsTo', symObjAddr: 0x148, symBinAddr: 0xD42C, symSize: 0x10 }
-  - { offsetInCU: 0x329, offset: 0x804B2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC6heightSivgTo', symObjAddr: 0x158, symBinAddr: 0xD43C, symSize: 0x10 }
-  - { offsetInCU: 0x349, offset: 0x804D2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC6heightSivgTo', symObjAddr: 0x158, symBinAddr: 0xD43C, symSize: 0x10 }
-  - { offsetInCU: 0x37F, offset: 0x80508, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC6heightSivsTo', symObjAddr: 0x168, symBinAddr: 0xD44C, symSize: 0x10 }
-  - { offsetInCU: 0x39F, offset: 0x80528, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC6heightSivsTo', symObjAddr: 0x168, symBinAddr: 0xD44C, symSize: 0x10 }
-  - { offsetInCU: 0x3D8, offset: 0x80561, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC2abs6UInt32VvgTo', symObjAddr: 0x178, symBinAddr: 0xD45C, symSize: 0x44 }
-  - { offsetInCU: 0x430, offset: 0x805B9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC2abs6UInt32VvsTo', symObjAddr: 0x1BC, symBinAddr: 0xD4A0, symSize: 0x48 }
-  - { offsetInCU: 0x48B, offset: 0x80614, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3poss5Int32VvgTo', symObjAddr: 0x204, symBinAddr: 0xD4E8, symSize: 0x10 }
-  - { offsetInCU: 0x4AB, offset: 0x80634, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3poss5Int32VvgTo', symObjAddr: 0x204, symBinAddr: 0xD4E8, symSize: 0x10 }
-  - { offsetInCU: 0x4E1, offset: 0x8066A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3poss5Int32VvsTo', symObjAddr: 0x214, symBinAddr: 0xD4F8, symSize: 0x10 }
-  - { offsetInCU: 0x501, offset: 0x8068A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3poss5Int32VvsTo', symObjAddr: 0x214, symBinAddr: 0xD4F8, symSize: 0x10 }
-  - { offsetInCU: 0x53A, offset: 0x806C3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10samplerPoss5Int32VvgTo', symObjAddr: 0x224, symBinAddr: 0xD508, symSize: 0x10 }
-  - { offsetInCU: 0x55A, offset: 0x806E3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10samplerPoss5Int32VvgTo', symObjAddr: 0x224, symBinAddr: 0xD508, symSize: 0x10 }
-  - { offsetInCU: 0x590, offset: 0x80719, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10samplerPoss5Int32VvsTo', symObjAddr: 0x234, symBinAddr: 0xD518, symSize: 0x10 }
-  - { offsetInCU: 0x5B0, offset: 0x80739, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10samplerPoss5Int32VvsTo', symObjAddr: 0x234, symBinAddr: 0xD518, symSize: 0x10 }
-  - { offsetInCU: 0x5E9, offset: 0x80772, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9vextexBufSaySfGvgTo', symObjAddr: 0x244, symBinAddr: 0xD528, symSize: 0x48 }
-  - { offsetInCU: 0x63F, offset: 0x807C8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9vextexBufSaySfGvsTo', symObjAddr: 0x28C, symBinAddr: 0xD570, symSize: 0x40 }
-  - { offsetInCU: 0x682, offset: 0x8080B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13SIZE_OF_FLOATSivgZTo', symObjAddr: 0x2CC, symBinAddr: 0xD5B0, symSize: 0x8 }
-  - { offsetInCU: 0x69E, offset: 0x80827, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13VERTEX_SHADERSSvgZTo', symObjAddr: 0x2D4, symBinAddr: 0xD5B8, symSize: 0x2C }
-  - { offsetInCU: 0x6D0, offset: 0x80859, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7surfaceSo9IOSurfaceCSgvgTo', symObjAddr: 0x300, symBinAddr: 0xD5E4, symSize: 0x10 }
-  - { offsetInCU: 0x6F0, offset: 0x80879, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7surfaceSo9IOSurfaceCSgvgTo', symObjAddr: 0x300, symBinAddr: 0xD5E4, symSize: 0x10 }
-  - { offsetInCU: 0x728, offset: 0x808B1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7surfaceSo9IOSurfaceCSgvsTo', symObjAddr: 0x310, symBinAddr: 0xD5F4, symSize: 0x34 }
-  - { offsetInCU: 0x781, offset: 0x8090A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8pixelBufs9UnmanagedVySo11CVBufferRefaGSgvgTo', symObjAddr: 0x418, symBinAddr: 0xD6FC, symSize: 0x10 }
-  - { offsetInCU: 0x7A1, offset: 0x8092A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8pixelBufs9UnmanagedVySo11CVBufferRefaGSgvgTo', symObjAddr: 0x418, symBinAddr: 0xD6FC, symSize: 0x10 }
-  - { offsetInCU: 0x7D7, offset: 0x80960, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8pixelBufs9UnmanagedVySo11CVBufferRefaGSgvsTo', symObjAddr: 0x428, symBinAddr: 0xD70C, symSize: 0x10 }
-  - { offsetInCU: 0x7F7, offset: 0x80980, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8pixelBufs9UnmanagedVySo11CVBufferRefaGSgvsTo', symObjAddr: 0x428, symBinAddr: 0xD70C, symSize: 0x10 }
-  - { offsetInCU: 0x846, offset: 0x809CF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCACycfcTo', symObjAddr: 0x5A4, symBinAddr: 0xD848, symSize: 0x20 }
-  - { offsetInCU: 0x878, offset: 0x80A01, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7destroyyyFTo', symObjAddr: 0x708, symBinAddr: 0xD9AC, symSize: 0x28 }
-  - { offsetInCU: 0x8D0, offset: 0x80A59, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10texImage2Dyys5Int32V_A4fA9NSCCanvasCAHSbtFTo', symObjAddr: 0x744, symBinAddr: 0xD9E8, symSize: 0x88 }
-  - { offsetInCU: 0x934, offset: 0x80ABD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9drawFrame6buffer5width6height14internalFormat6format10flipYWebGLySo11CVBufferRefa_S2is5Int32VANSbtFTo', symObjAddr: 0x7CC, symBinAddr: 0xDA70, symSize: 0x7C }
-  - { offsetInCU: 0x9D6, offset: 0x80B5F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13createSurfaceyyFTo', symObjAddr: 0xBF4, symBinAddr: 0xDE98, symSize: 0x28 }
-  - { offsetInCU: 0xAC0, offset: 0x80C49, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCMa', symObjAddr: 0x584, symBinAddr: 0xD828, symSize: 0x20 }
-  - { offsetInCU: 0xB34, offset: 0x80CBD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCfETo', symObjAddr: 0xC4C, symBinAddr: 0xDEF0, symSize: 0x58 }
-  - { offsetInCU: 0x123B, offset: 0x813C4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCACycfC', symObjAddr: 0x438, symBinAddr: 0xD71C, symSize: 0x20 }
-  - { offsetInCU: 0x1255, offset: 0x813DE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCACycfc', symObjAddr: 0x458, symBinAddr: 0xD73C, symSize: 0xEC }
-  - { offsetInCU: 0x128D, offset: 0x81416, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7destroyyyF', symObjAddr: 0x5C4, symBinAddr: 0xD868, symSize: 0x144 }
-  - { offsetInCU: 0x1448, offset: 0x815D1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10texImage2Dyys5Int32V_A4fA9NSCCanvasCAHSbtF', symObjAddr: 0x730, symBinAddr: 0xD9D4, symSize: 0x14 }
-  - { offsetInCU: 0x14F9, offset: 0x81682, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13createSurfaceyyF', symObjAddr: 0x848, symBinAddr: 0xDAEC, symSize: 0x3AC }
-  - { offsetInCU: 0x1869, offset: 0x819F2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCfD', symObjAddr: 0xC1C, symBinAddr: 0xDEC0, symSize: 0x30 }
-  - { offsetInCU: 0x1954, offset: 0x81ADD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10texImage2Dyys5Int32V_A4fA9NSCCanvasCAHSbtFTf4ddnndnndn_n', symObjAddr: 0xCA4, symBinAddr: 0xDF48, symSize: 0x65C }
-  - { offsetInCU: 0x2152, offset: 0x822DB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9drawFrame6buffer5width6height14internalFormat6format10flipYWebGLySo11CVBufferRefa_S2is5Int32VANSbtFTf4nnnnndn_n', symObjAddr: 0x1344, symBinAddr: 0xE5E8, symSize: 0x6C8 }
-  - { offsetInCU: 0x10C, offset: 0x82C9B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC6target6actionAEypSg_10ObjectiveC8SelectorVSgtcfcTo', symObjAddr: 0xED4, symBinAddr: 0xFB5C, symSize: 0x68 }
-  - { offsetInCU: 0x19C, offset: 0x82D2B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerCfETo', symObjAddr: 0xF48, symBinAddr: 0xFBD0, symSize: 0x10 }
-  - { offsetInCU: 0x1CB, offset: 0x82D5A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC6handleyySo19UIGestureRecognizerCFTo', symObjAddr: 0xF58, symBinAddr: 0xFBE0, symSize: 0x4 }
-  - { offsetInCU: 0x368, offset: 0x82EF7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerCACycfcTo', symObjAddr: 0x16DC, symBinAddr: 0x10364, symSize: 0x2C }
-  - { offsetInCU: 0x5D4, offset: 0x83163, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerCfETo', symObjAddr: 0x1744, symBinAddr: 0x103CC, symSize: 0x68 }
-  - { offsetInCU: 0x603, offset: 0x83192, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerCMa', symObjAddr: 0x17AC, symBinAddr: 0x10434, symSize: 0x20 }
-  - { offsetInCU: 0x617, offset: 0x831A6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerCMa', symObjAddr: 0x17CC, symBinAddr: 0x10454, symSize: 0x20 }
-  - { offsetInCU: 0x62B, offset: 0x831BA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwCP', symObjAddr: 0x17EC, symBinAddr: 0x10474, symSize: 0x30 }
-  - { offsetInCU: 0x63F, offset: 0x831CE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwxx', symObjAddr: 0x181C, symBinAddr: 0x104A4, symSize: 0x8 }
-  - { offsetInCU: 0x653, offset: 0x831E2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwcp', symObjAddr: 0x1824, symBinAddr: 0x104AC, symSize: 0x3C }
-  - { offsetInCU: 0x667, offset: 0x831F6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwca', symObjAddr: 0x1860, symBinAddr: 0x104E8, symSize: 0x50 }
-  - { offsetInCU: 0x67B, offset: 0x8320A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwta', symObjAddr: 0x18BC, symBinAddr: 0x10538, symSize: 0x40 }
-  - { offsetInCU: 0x68F, offset: 0x8321E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwet', symObjAddr: 0x18FC, symBinAddr: 0x10578, symSize: 0x48 }
-  - { offsetInCU: 0x6A3, offset: 0x83232, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwst', symObjAddr: 0x1944, symBinAddr: 0x105C0, symSize: 0x40 }
-  - { offsetInCU: 0x6B7, offset: 0x83246, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVMa', symObjAddr: 0x1984, symBinAddr: 0x10600, symSize: 0x10 }
-  - { offsetInCU: 0x6CB, offset: 0x8325A, size: 0x8, addend: 0x0, symName: '_$sypSgWOc', symObjAddr: 0x1994, symBinAddr: 0x10610, symSize: 0x48 }
-  - { offsetInCU: 0x6DF, offset: 0x8326E, size: 0x8, addend: 0x0, symName: '_$sSo7UITouchCSo8NSObjectCSH10ObjectiveCWl', symObjAddr: 0x1AA0, symBinAddr: 0x10658, symSize: 0x58 }
-  - { offsetInCU: 0x6F3, offset: 0x83282, size: 0x8, addend: 0x0, symName: '_$sSh8IteratorV8_VariantOyx__GSHRzlWOe', symObjAddr: 0x1AF8, symBinAddr: 0x106B0, symSize: 0x8 }
-  - { offsetInCU: 0x761, offset: 0x832F0, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_SgWOe', symObjAddr: 0x1DE4, symBinAddr: 0x1099C, symSize: 0x10 }
-  - { offsetInCU: 0xCBB, offset: 0x8384A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC12touchesBegan_4withyShySo7UITouchCG_So7UIEventCtF', symObjAddr: 0x0, symBinAddr: 0xECB0, symSize: 0x540 }
-  - { offsetInCU: 0xF57, offset: 0x83AE6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC12touchesMoved_4withyShySo7UITouchCG_So7UIEventCtF', symObjAddr: 0x54C, symBinAddr: 0xF1FC, symSize: 0xE0 }
-  - { offsetInCU: 0xFD6, offset: 0x83B65, size: 0x8, addend: 0x0, symName: '_$sSa6remove2atxSi_tF12CanvasNative15NSCTouchHandlerC7PointerV_Tg5', symObjAddr: 0x6F0, symBinAddr: 0xF38C, symSize: 0x9C }
-  - { offsetInCU: 0x1069, offset: 0x83BF8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC6target6actionAEypSg_10ObjectiveC8SelectorVSgtcfc', symObjAddr: 0xDCC, symBinAddr: 0xFA54, symSize: 0x108 }
-  - { offsetInCU: 0x11B3, offset: 0x83D42, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC6onMove33_044DDF836BDB3B89B481C6F58BB6EF6BLLyySo19UIGestureRecognizerC_ShySo7UITouchCGSgtF', symObjAddr: 0x12D0, symBinAddr: 0xFF58, symSize: 0x40C }
-  - { offsetInCU: 0x18C9, offset: 0x84458, size: 0x8, addend: 0x0, symName: '_$ss12_ArrayBufferV20_consumeAndCreateNewAByxGyF12CanvasNative15NSCTouchHandlerC7PointerV_Tg5', symObjAddr: 0x1B00, symBinAddr: 0x106B8, symSize: 0x14 }
-  - { offsetInCU: 0x1968, offset: 0x844F7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC6canvasAcA9NSCCanvasC_tcfcTf4gn_n', symObjAddr: 0x1B14, symBinAddr: 0x106CC, symSize: 0x1DC }
-  - { offsetInCU: 0x27, offset: 0x846D4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC14FAILED_TO_LOADSSvgZTo', symObjAddr: 0x0, symBinAddr: 0x109AC, symSize: 0x2C }
-  - { offsetInCU: 0x4B, offset: 0x846F8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queueSo012OS_dispatch_E0CvpZ', symObjAddr: 0x2D8, symBinAddr: 0x10C4068, symSize: 0x0 }
-  - { offsetInCU: 0x65, offset: 0x84712, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC14FAILED_TO_LOADSSvgZTo', symObjAddr: 0x0, symBinAddr: 0x109AC, symSize: 0x2C }
-  - { offsetInCU: 0x98, offset: 0x84745, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queueSo012OS_dispatch_E0CvgZTo', symObjAddr: 0x178, symBinAddr: 0x10B24, symSize: 0x40 }
-  - { offsetInCU: 0x104, offset: 0x847B1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCACycfcTo', symObjAddr: 0x228, symBinAddr: 0x10BD4, symSize: 0x3C }
-  - { offsetInCU: 0x156, offset: 0x84803, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queue_WZ', symObjAddr: 0x2C, symBinAddr: 0x109D8, symSize: 0x10C }
-  - { offsetInCU: 0x181, offset: 0x8482E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCMa', symObjAddr: 0x208, symBinAddr: 0x10BB4, symSize: 0x20 }
-  - { offsetInCU: 0x195, offset: 0x84842, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCfETo', symObjAddr: 0x294, symBinAddr: 0x10C40, symSize: 0x4 }
-  - { offsetInCU: 0x1C0, offset: 0x8486D, size: 0x8, addend: 0x0, symName: '_$sSo17OS_dispatch_queueCMa', symObjAddr: 0x298, symBinAddr: 0x10C44, symSize: 0x3C }
-  - { offsetInCU: 0x348, offset: 0x849F5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queueSo012OS_dispatch_E0CvgZ', symObjAddr: 0x138, symBinAddr: 0x10AE4, symSize: 0x40 }
-  - { offsetInCU: 0x388, offset: 0x84A35, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCACycfC', symObjAddr: 0x1B8, symBinAddr: 0x10B64, symSize: 0x20 }
-  - { offsetInCU: 0x39C, offset: 0x84A49, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCACycfc', symObjAddr: 0x1D8, symBinAddr: 0x10B84, symSize: 0x30 }
-  - { offsetInCU: 0x3D8, offset: 0x84A85, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCfD', symObjAddr: 0x264, symBinAddr: 0x10C10, symSize: 0x30 }
-  - { offsetInCU: 0x2B, offset: 0x84AD3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC18createTextureCacheSo017CVOpenGLESTextureF3RefaSgyFZ', symObjAddr: 0x0, symBinAddr: 0x10C80, symSize: 0xA4 }
-  - { offsetInCU: 0x66, offset: 0x84B0E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC18createTextureCacheSo017CVOpenGLESTextureF3RefaSgyFZTo', symObjAddr: 0xA4, symBinAddr: 0x10D24, symSize: 0xA4 }
-  - { offsetInCU: 0xF9, offset: 0x84BA1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11createImageySo11CVBufferRefaSgSo022CVOpenGLESTextureCacheG0a_AFSo012CFDictionaryG0aSgs6UInt32Vs5Int32VA2p2NSitFZTo', symObjAddr: 0x1D8, symBinAddr: 0x10E58, symSize: 0x110 }
-  - { offsetInCU: 0x1A2, offset: 0x84C4A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11setupRenderAA9NSCRenderCyFZTo', symObjAddr: 0x30C, symBinAddr: 0x10F8C, symSize: 0x28 }
-  - { offsetInCU: 0x222, offset: 0x84CCA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC9drawFrameyySo8AVPlayerC_So0F15ItemVideoOutputCSo6CGSizeVAA9NSCRenderCs5Int32VANSbtFZTo', symObjAddr: 0x338, symBinAddr: 0x10FB8, symSize: 0xA0 }
-  - { offsetInCU: 0x29B, offset: 0x84D43, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11writeToFileyySo6NSDataC_SStKFZTo', symObjAddr: 0x4D0, symBinAddr: 0x11150, symSize: 0x15C }
-  - { offsetInCU: 0x330, offset: 0x84DD8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCACycfcTo', symObjAddr: 0x67C, symBinAddr: 0x112FC, symSize: 0x3C }
-  - { offsetInCU: 0x381, offset: 0x84E29, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC9drawFrameyySo8AVPlayerC_So0F15ItemVideoOutputCSo6CGSizeVAA9NSCRenderCs5Int32VANSbtFZTf4nnnnnndd_n', symObjAddr: 0x6E8, symBinAddr: 0x11368, symSize: 0x160 }
-  - { offsetInCU: 0x4DF, offset: 0x84F87, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC7getFile33_F00B23A4165DD6ABFCD23C8811C7DF43LLyS2SKFZTf4nd_g', symObjAddr: 0x848, symBinAddr: 0x114C8, symSize: 0x2E4 }
-  - { offsetInCU: 0x5AE, offset: 0x85056, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCMa', symObjAddr: 0xB2C, symBinAddr: 0x117AC, symSize: 0x20 }
-  - { offsetInCU: 0x5C2, offset: 0x8506A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOAEs5ErrorAAWl', symObjAddr: 0xB4C, symBinAddr: 0x117CC, symSize: 0x44 }
-  - { offsetInCU: 0x5D6, offset: 0x8507E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwCP', symObjAddr: 0xB90, symBinAddr: 0x11810, symSize: 0x2C }
-  - { offsetInCU: 0x5EA, offset: 0x85092, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwxx', symObjAddr: 0xBBC, symBinAddr: 0x1183C, symSize: 0x8 }
-  - { offsetInCU: 0x5FE, offset: 0x850A6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwca', symObjAddr: 0xBC4, symBinAddr: 0x11844, symSize: 0x40 }
-  - { offsetInCU: 0x612, offset: 0x850BA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwta', symObjAddr: 0xC10, symBinAddr: 0x11884, symSize: 0x30 }
-  - { offsetInCU: 0x626, offset: 0x850CE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwet', symObjAddr: 0xC40, symBinAddr: 0x118B4, symSize: 0x48 }
-  - { offsetInCU: 0x63A, offset: 0x850E2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwst', symObjAddr: 0xC88, symBinAddr: 0x118FC, symSize: 0x3C }
-  - { offsetInCU: 0x64E, offset: 0x850F6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwug', symObjAddr: 0xCC4, symBinAddr: 0x11938, symSize: 0x8 }
-  - { offsetInCU: 0x662, offset: 0x8510A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwup', symObjAddr: 0xCCC, symBinAddr: 0x11940, symSize: 0x4 }
-  - { offsetInCU: 0x676, offset: 0x8511E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwui', symObjAddr: 0xCD0, symBinAddr: 0x11944, symSize: 0x4 }
-  - { offsetInCU: 0x68A, offset: 0x85132, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOMa', symObjAddr: 0xCD4, symBinAddr: 0x11948, symSize: 0x10 }
-  - { offsetInCU: 0x712, offset: 0x851BA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP7_domainSSvgTW', symObjAddr: 0x3D8, symBinAddr: 0x11058, symSize: 0x4 }
-  - { offsetInCU: 0x72E, offset: 0x851D6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP5_codeSivgTW', symObjAddr: 0x3DC, symBinAddr: 0x1105C, symSize: 0x4 }
-  - { offsetInCU: 0x74A, offset: 0x851F2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP9_userInfoyXlSgvgTW', symObjAddr: 0x3E0, symBinAddr: 0x11060, symSize: 0x4 }
-  - { offsetInCU: 0x766, offset: 0x8520E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP19_getEmbeddedNSErroryXlSgyFTW', symObjAddr: 0x3E4, symBinAddr: 0x11064, symSize: 0x4 }
-  - { offsetInCU: 0xA14, offset: 0x854BC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC18createTextureCacheSo017CVOpenGLESTextureF3RefaSgyFZ', symObjAddr: 0x0, symBinAddr: 0x10C80, symSize: 0xA4 }
-  - { offsetInCU: 0xAAA, offset: 0x85552, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11createImageySo11CVBufferRefaSgSo022CVOpenGLESTextureCacheG0a_AFSo012CFDictionaryG0aSgs6UInt32Vs5Int32VA2p2NSitFZ', symObjAddr: 0x148, symBinAddr: 0x10DC8, symSize: 0x90 }
-  - { offsetInCU: 0xC31, offset: 0x856D9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11setupRenderAA9NSCRenderCyFZ', symObjAddr: 0x2E8, symBinAddr: 0x10F68, symSize: 0x24 }
-  - { offsetInCU: 0xC7B, offset: 0x85723, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC9drawFrameyySo8AVPlayerC_So0F15ItemVideoOutputCSo6CGSizeVAA9NSCRenderCs5Int32VANSbtFZ', symObjAddr: 0x334, symBinAddr: 0x10FB4, symSize: 0x4 }
-  - { offsetInCU: 0xC9D, offset: 0x85745, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11writeToFileyySo6NSDataC_SStKFZ', symObjAddr: 0x3E8, symBinAddr: 0x11068, symSize: 0xE8 }
-  - { offsetInCU: 0xD4D, offset: 0x857F5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCACycfC', symObjAddr: 0x62C, symBinAddr: 0x112AC, symSize: 0x20 }
-  - { offsetInCU: 0xD61, offset: 0x85809, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCACycfc', symObjAddr: 0x64C, symBinAddr: 0x112CC, symSize: 0x30 }
-  - { offsetInCU: 0xD97, offset: 0x8583F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCfD', symObjAddr: 0x6B8, symBinAddr: 0x11338, symSize: 0x30 }
-  - { offsetInCU: 0x27, offset: 0x85958, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x0, symBinAddr: 0x1195C, symSize: 0x4 }
-  - { offsetInCU: 0x71, offset: 0x859A2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZTo', symObjAddr: 0x4, symBinAddr: 0x11960, symSize: 0x70 }
-  - { offsetInCU: 0xF6, offset: 0x85A27, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS2ftFZTo', symObjAddr: 0x78, symBinAddr: 0x119D4, symSize: 0x50 }
-  - { offsetInCU: 0x191, offset: 0x85AC2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS4ftFZTo', symObjAddr: 0xCC, symBinAddr: 0x11A28, symSize: 0x68 }
-  - { offsetInCU: 0x254, offset: 0x85B85, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS8ftFZTo', symObjAddr: 0x138, symBinAddr: 0x11A94, symSize: 0x98 }
-  - { offsetInCU: 0x323, offset: 0x85C54, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCACycfcTo', symObjAddr: 0x220, symBinAddr: 0x11B7C, symSize: 0x3C }
-  - { offsetInCU: 0x375, offset: 0x85CA6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCMa', symObjAddr: 0x28C, symBinAddr: 0x11BE8, symSize: 0x20 }
-  - { offsetInCU: 0x4E5, offset: 0x85E16, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x0, symBinAddr: 0x1195C, symSize: 0x4 }
-  - { offsetInCU: 0x51D, offset: 0x85E4E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x0, symBinAddr: 0x1195C, symSize: 0x4 }
-  - { offsetInCU: 0x588, offset: 0x85EB9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS2ftFZ', symObjAddr: 0x74, symBinAddr: 0x119D0, symSize: 0x4 }
-  - { offsetInCU: 0x5C8, offset: 0x85EF9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS2ftFZ', symObjAddr: 0x74, symBinAddr: 0x119D0, symSize: 0x4 }
-  - { offsetInCU: 0x62A, offset: 0x85F5B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS4ftFZ', symObjAddr: 0xC8, symBinAddr: 0x11A24, symSize: 0x4 }
-  - { offsetInCU: 0x67C, offset: 0x85FAD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS4ftFZ', symObjAddr: 0xC8, symBinAddr: 0x11A24, symSize: 0x4 }
-  - { offsetInCU: 0x6F1, offset: 0x86022, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS8ftFZ', symObjAddr: 0x134, symBinAddr: 0x11A90, symSize: 0x4 }
-  - { offsetInCU: 0x767, offset: 0x86098, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS8ftFZ', symObjAddr: 0x134, symBinAddr: 0x11A90, symSize: 0x4 }
-  - { offsetInCU: 0x805, offset: 0x86136, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCACycfC', symObjAddr: 0x1D0, symBinAddr: 0x11B2C, symSize: 0x20 }
-  - { offsetInCU: 0x819, offset: 0x8614A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCACycfc', symObjAddr: 0x1F0, symBinAddr: 0x11B4C, symSize: 0x30 }
-  - { offsetInCU: 0x84F, offset: 0x86180, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCfD', symObjAddr: 0x25C, symBinAddr: 0x11BB8, symSize: 0x30 }
-  - { offsetInCU: 0x27, offset: 0x861CA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC10texImage2Dyys5Int64V_s5Int32VA4HSpys5UInt8VGSuSo6CGSizeVSbtFZ', symObjAddr: 0x0, symBinAddr: 0x11C08, symSize: 0x14 }
-  - { offsetInCU: 0xA9, offset: 0x8624C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC10texImage2Dyys5Int64V_s5Int32VA4HSpys5UInt8VGSuSo6CGSizeVSbtFZTo', symObjAddr: 0x14, symBinAddr: 0x11C1C, symSize: 0x38 }
-  - { offsetInCU: 0x1A2, offset: 0x86345, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC13texSubImage2Dyys5Int64V_s5Int32VA5HSpys5UInt8VGSuSo6CGSizeVSbtFZTo', symObjAddr: 0x68, symBinAddr: 0x11C70, symSize: 0x40 }
-  - { offsetInCU: 0x284, offset: 0x86427, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCACycfcTo', symObjAddr: 0x118, symBinAddr: 0x11D20, symSize: 0x3C }
-  - { offsetInCU: 0x2D6, offset: 0x86479, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCMa', symObjAddr: 0xF8, symBinAddr: 0x11D00, symSize: 0x20 }
-  - { offsetInCU: 0x480, offset: 0x86623, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC10texImage2Dyys5Int64V_s5Int32VA4HSpys5UInt8VGSuSo6CGSizeVSbtFZ', symObjAddr: 0x0, symBinAddr: 0x11C08, symSize: 0x14 }
-  - { offsetInCU: 0x5C4, offset: 0x86767, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC13texSubImage2Dyys5Int64V_s5Int32VA5HSpys5UInt8VGSuSo6CGSizeVSbtFZ', symObjAddr: 0x4C, symBinAddr: 0x11C54, symSize: 0x1C }
-  - { offsetInCU: 0x6FA, offset: 0x8689D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCACycfC', symObjAddr: 0xA8, symBinAddr: 0x11CB0, symSize: 0x20 }
-  - { offsetInCU: 0x70E, offset: 0x868B1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCACycfc', symObjAddr: 0xC8, symBinAddr: 0x11CD0, symSize: 0x30 }
-  - { offsetInCU: 0x744, offset: 0x868E7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCfD', symObjAddr: 0x154, symBinAddr: 0x11D5C, symSize: 0x30 }
-  - { offsetInCU: 0x61, offset: 0x8696B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7isDirtySbvgTo', symObjAddr: 0x4, symBinAddr: 0x11D90, symSize: 0x10 }
-  - { offsetInCU: 0x81, offset: 0x8698B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7isDirtySbvgTo', symObjAddr: 0x4, symBinAddr: 0x11D90, symSize: 0x10 }
-  - { offsetInCU: 0xB7, offset: 0x869C1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7isDirtySbvsTo', symObjAddr: 0x14, symBinAddr: 0x11DA0, symSize: 0x10 }
-  - { offsetInCU: 0xD7, offset: 0x869E1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7isDirtySbvsTo', symObjAddr: 0x14, symBinAddr: 0x11DA0, symSize: 0x10 }
-  - { offsetInCU: 0x110, offset: 0x86A1A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC6canvasAA9NSCCanvasCSgvgTo', symObjAddr: 0x24, symBinAddr: 0x11DB0, symSize: 0x48 }
-  - { offsetInCU: 0x168, offset: 0x86A72, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC6canvasAA9NSCCanvasCSgvsTo', symObjAddr: 0xB4, symBinAddr: 0x11E40, symSize: 0x50 }
-  - { offsetInCU: 0x1C3, offset: 0x86ACD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC3fbos6UInt32VvgTo', symObjAddr: 0x104, symBinAddr: 0x11E90, symSize: 0x10 }
-  - { offsetInCU: 0x1E3, offset: 0x86AED, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC3fbos6UInt32VvgTo', symObjAddr: 0x104, symBinAddr: 0x11E90, symSize: 0x10 }
-  - { offsetInCU: 0x219, offset: 0x86B23, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC3fbos6UInt32VvsTo', symObjAddr: 0x114, symBinAddr: 0x11EA0, symSize: 0x10 }
-  - { offsetInCU: 0x239, offset: 0x86B43, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC3fbos6UInt32VvsTo', symObjAddr: 0x114, symBinAddr: 0x11EA0, symSize: 0x10 }
-  - { offsetInCU: 0x272, offset: 0x86B7C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCACycfcTo', symObjAddr: 0x1B0, symBinAddr: 0x11F3C, symSize: 0x78 }
-  - { offsetInCU: 0x2C8, offset: 0x86BD2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frameACSo6CGRectV_tcfcTo', symObjAddr: 0x2D4, symBinAddr: 0x12060, symSize: 0xB0 }
-  - { offsetInCU: 0x32A, offset: 0x86C34, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5coderACSgSo7NSCoderC_tcfcTo', symObjAddr: 0x43C, symBinAddr: 0x121C8, symSize: 0x28 }
-  - { offsetInCU: 0x35C, offset: 0x86C66, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC12bindDrawableyyFTo', symObjAddr: 0x4E0, symBinAddr: 0x121F0, symSize: 0xA0 }
-  - { offsetInCU: 0x3DD, offset: 0x86CE7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC14deleteDrawableyyFTo', symObjAddr: 0x5BC, symBinAddr: 0x12290, symSize: 0x60 }
-  - { offsetInCU: 0x44D, offset: 0x86D57, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7glkView_6drawInySo0C0C_So6CGRectVtFTo', symObjAddr: 0x620, symBinAddr: 0x122F4, symSize: 0x4C }
-  - { offsetInCU: 0x4BF, offset: 0x86DC9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frame7contextACSo6CGRectV_So11EAGLContextCtcfcTo', symObjAddr: 0x70C, symBinAddr: 0x123E0, symSize: 0x34 }
-  - { offsetInCU: 0x533, offset: 0x86E3D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCMa', symObjAddr: 0x190, symBinAddr: 0x11F1C, symSize: 0x20 }
-  - { offsetInCU: 0x55D, offset: 0x86E67, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCfETo', symObjAddr: 0x74C, symBinAddr: 0x12420, symSize: 0x10 }
-  - { offsetInCU: 0x65B, offset: 0x86F65, size: 0x8, addend: 0x0, symName: '_$sSo7GLKViewC12CanvasNativeE16snapshotWithDatayy10Foundation0F0VFTo', symObjAddr: 0xA08, symBinAddr: 0x126DC, symSize: 0x74 }
-  - { offsetInCU: 0x699, offset: 0x86FA3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC7isDirtySbvgTo', symObjAddr: 0xA7C, symBinAddr: 0x12750, symSize: 0x10 }
-  - { offsetInCU: 0x6B9, offset: 0x86FC3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC7isDirtySbvgTo', symObjAddr: 0xA7C, symBinAddr: 0x12750, symSize: 0x10 }
-  - { offsetInCU: 0x6EF, offset: 0x86FF9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC7isDirtySbvsTo', symObjAddr: 0xA8C, symBinAddr: 0x12760, symSize: 0x10 }
-  - { offsetInCU: 0x70F, offset: 0x87019, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC7isDirtySbvsTo', symObjAddr: 0xA8C, symBinAddr: 0x12760, symSize: 0x10 }
-  - { offsetInCU: 0x748, offset: 0x87052, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC8rendererAA9NSCCanvasCSgvgTo', symObjAddr: 0xA9C, symBinAddr: 0x12770, symSize: 0x20 }
-  - { offsetInCU: 0x7A0, offset: 0x870AA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC8rendererAA9NSCCanvasCSgvsTo', symObjAddr: 0xABC, symBinAddr: 0x12790, symSize: 0x14 }
-  - { offsetInCU: 0x7FB, offset: 0x87105, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvgTo', symObjAddr: 0xAD0, symBinAddr: 0x127A4, symSize: 0x44 }
-  - { offsetInCU: 0x853, offset: 0x8715D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvsTo', symObjAddr: 0xB58, symBinAddr: 0x1282C, symSize: 0x48 }
-  - { offsetInCU: 0x8E8, offset: 0x871F2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCACycfcTo', symObjAddr: 0xCBC, symBinAddr: 0x12990, symSize: 0x78 }
-  - { offsetInCU: 0x93E, offset: 0x87248, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5frameACSo6CGRectV_tcfcTo', symObjAddr: 0xE34, symBinAddr: 0x12B08, symSize: 0xB0 }
-  - { offsetInCU: 0x9A0, offset: 0x872AA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5coderACSgSo7NSCoderC_tcfcTo', symObjAddr: 0xF90, symBinAddr: 0x12C64, symSize: 0x28 }
-  - { offsetInCU: 0x9D2, offset: 0x872DC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC11deviceScaleSfyFTo', symObjAddr: 0xFB8, symBinAddr: 0x12C8C, symSize: 0xB8 }
-  - { offsetInCU: 0xA53, offset: 0x8735D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC4drawyySo6CGRectVFTo', symObjAddr: 0x1074, symBinAddr: 0x12D44, symSize: 0x28 }
-  - { offsetInCU: 0xAB1, offset: 0x873BB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCfETo', symObjAddr: 0x10D8, symBinAddr: 0x12DA8, symSize: 0x10 }
-  - { offsetInCU: 0xC88, offset: 0x87592, size: 0x8, addend: 0x0, symName: '_$ss22_ContiguousArrayBufferV19_uninitializedCount15minimumCapacityAByxGSi_SitcfCs5UInt8V_Tgmq5', symObjAddr: 0x13D0, symBinAddr: 0x12FA4, symSize: 0x64 }
-  - { offsetInCU: 0xCD9, offset: 0x875E3, size: 0x8, addend: 0x0, symName: '_$s10Foundation4DataV15_RepresentationOWOy', symObjAddr: 0x15D8, symBinAddr: 0x131AC, symSize: 0x44 }
-  - { offsetInCU: 0xCED, offset: 0x875F7, size: 0x8, addend: 0x0, symName: '_$s10Foundation4DataV15_RepresentationOWOe', symObjAddr: 0x161C, symBinAddr: 0x131F0, symSize: 0x44 }
-  - { offsetInCU: 0xD01, offset: 0x8760B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCMa', symObjAddr: 0x1660, symBinAddr: 0x13234, symSize: 0x20 }
-  - { offsetInCU: 0xDDB, offset: 0x876E5, size: 0x8, addend: 0x0, symName: '_$sSaySayxGqd__c7ElementQyd__RszSTRd__lufCs5UInt8V_10Foundation4DataVTgm5Tf4g_n', symObjAddr: 0x14B8, symBinAddr: 0x1308C, symSize: 0x110 }
-  - { offsetInCU: 0x1086, offset: 0x87990, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC6canvasAA9NSCCanvasCSgvg', symObjAddr: 0x6C, symBinAddr: 0x11DF8, symSize: 0x48 }
-  - { offsetInCU: 0x1103, offset: 0x87A0D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCACycfc', symObjAddr: 0x124, symBinAddr: 0x11EB0, symSize: 0x6C }
-  - { offsetInCU: 0x114A, offset: 0x87A54, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frameACSo6CGRectV_tcfc', symObjAddr: 0x228, symBinAddr: 0x11FB4, symSize: 0xAC }
-  - { offsetInCU: 0x11AE, offset: 0x87AB8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5coderACSgSo7NSCoderC_tcfc', symObjAddr: 0x384, symBinAddr: 0x12110, symSize: 0xB8 }
-  - { offsetInCU: 0x1239, offset: 0x87B43, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7glkView_6drawInySo0C0C_So6CGRectVtF', symObjAddr: 0x61C, symBinAddr: 0x122F0, symSize: 0x4 }
-  - { offsetInCU: 0x125A, offset: 0x87B64, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frame7contextACSo6CGRectV_So11EAGLContextCtcfC', symObjAddr: 0x66C, symBinAddr: 0x12340, symSize: 0x74 }
-  - { offsetInCU: 0x126E, offset: 0x87B78, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frame7contextACSo6CGRectV_So11EAGLContextCtcfc', symObjAddr: 0x6E0, symBinAddr: 0x123B4, symSize: 0x2C }
-  - { offsetInCU: 0x1387, offset: 0x87C91, size: 0x8, addend: 0x0, symName: '_$sSo7GLKViewC12CanvasNativeE16snapshotWithDatayy10Foundation0F0VF', symObjAddr: 0x75C, symBinAddr: 0x12430, symSize: 0x2AC }
-  - { offsetInCU: 0x1731, offset: 0x8803B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvg', symObjAddr: 0xB14, symBinAddr: 0x127E8, symSize: 0x44 }
-  - { offsetInCU: 0x1770, offset: 0x8807A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvs', symObjAddr: 0xBA0, symBinAddr: 0x12874, symSize: 0x48 }
-  - { offsetInCU: 0x1795, offset: 0x8809F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvM', symObjAddr: 0xBE8, symBinAddr: 0x128BC, symSize: 0x44 }
-  - { offsetInCU: 0x17BA, offset: 0x880C4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvM.resume.0', symObjAddr: 0xC2C, symBinAddr: 0x12900, symSize: 0x4 }
-  - { offsetInCU: 0x17E1, offset: 0x880EB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCACycfC', symObjAddr: 0xC30, symBinAddr: 0x12904, symSize: 0x20 }
-  - { offsetInCU: 0x17F5, offset: 0x880FF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCACycfc', symObjAddr: 0xC50, symBinAddr: 0x12924, symSize: 0x6C }
-  - { offsetInCU: 0x183C, offset: 0x88146, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5frameACSo6CGRectV_tcfc', symObjAddr: 0xD88, symBinAddr: 0x12A5C, symSize: 0xAC }
-  - { offsetInCU: 0x189B, offset: 0x881A5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5coderACSgSo7NSCoderC_tcfc', symObjAddr: 0xEE4, symBinAddr: 0x12BB8, symSize: 0xAC }
-  - { offsetInCU: 0x1940, offset: 0x8824A, size: 0x8, addend: 0x0, symName: '_$ss12_ArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtF12CanvasNative15NSCTouchHandlerC7PointerV_Tg5', symObjAddr: 0x10E8, symBinAddr: 0x12DB8, symSize: 0x104 }
-  - { offsetInCU: 0x1A6F, offset: 0x88379, size: 0x8, addend: 0x0, symName: '_$ss12_ArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtFs5UInt8V_Tg5', symObjAddr: 0x12E8, symBinAddr: 0x12EBC, symSize: 0xE8 }
-  - { offsetInCU: 0x1BB3, offset: 0x884BD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7glkView_6drawInySo0C0C_So6CGRectVtFTf4ddn_n', symObjAddr: 0x1434, symBinAddr: 0x13008, symSize: 0x84 }
-  - { offsetInCU: 0x1CAC, offset: 0x885B6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC4drawyySo6CGRectVFTf4dn_n', symObjAddr: 0x1680, symBinAddr: 0x13254, symSize: 0x360 }
-  - { offsetInCU: 0x2B, offset: 0x889D0, size: 0x8, addend: 0x0, symName: '_$sIegh_IeyBh_TR', symObjAddr: 0x0, symBinAddr: 0x137A0, symSize: 0x2C }
-  - { offsetInCU: 0x4F, offset: 0x889F4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC5queue33_7ED578B0ED4B2B6F6887A622A7B49AA3LLSo012OS_dispatch_E0CvpZ', symObjAddr: 0x958, symBinAddr: 0x10C41B0, symSize: 0x0 }
-  - { offsetInCU: 0x5D, offset: 0x88A02, size: 0x8, addend: 0x0, symName: '_$sIegh_IeyBh_TR', symObjAddr: 0x0, symBinAddr: 0x137A0, symSize: 0x2C }
-  - { offsetInCU: 0x75, offset: 0x88A1A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC5queue33_7ED578B0ED4B2B6F6887A622A7B49AA3LL_WZ', symObjAddr: 0x2C, symBinAddr: 0x137CC, symSize: 0x10C }
-  - { offsetInCU: 0xBC, offset: 0x88A61, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF4SyncySbs5Int64V_So7UIImageCtFZTo', symObjAddr: 0x13C, symBinAddr: 0x138DC, symSize: 0x44 }
-  - { offsetInCU: 0x132, offset: 0x88AD7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZTo', symObjAddr: 0x3AC, symBinAddr: 0x13B4C, symSize: 0x80 }
-  - { offsetInCU: 0x191, offset: 0x88B36, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCACycfcTo', symObjAddr: 0x47C, symBinAddr: 0x13C1C, symSize: 0x3C }
-  - { offsetInCU: 0x1E2, offset: 0x88B87, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZTf4nnnd_n', symObjAddr: 0x4EC, symBinAddr: 0x13C8C, symSize: 0x1DC }
-  - { offsetInCU: 0x269, offset: 0x88C0E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCfETo', symObjAddr: 0x4E8, symBinAddr: 0x13C88, symSize: 0x4 }
-  - { offsetInCU: 0x2A5, offset: 0x88C4A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCMa', symObjAddr: 0x6C8, symBinAddr: 0x13E68, symSize: 0x20 }
-  - { offsetInCU: 0x2C4, offset: 0x88C69, size: 0x8, addend: 0x0, symName: '_$s10ObjectiveC8ObjCBoolVIeyBy_SbIegy_TRTA', symObjAddr: 0x70C, symBinAddr: 0x13EAC, symSize: 0x14 }
-  - { offsetInCU: 0x2ED, offset: 0x88C92, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_TA', symObjAddr: 0x74C, symBinAddr: 0x13EEC, symSize: 0xC }
-  - { offsetInCU: 0x301, offset: 0x88CA6, size: 0x8, addend: 0x0, symName: _block_copy_helper, symObjAddr: 0x758, symBinAddr: 0x13EF8, symSize: 0x10 }
-  - { offsetInCU: 0x315, offset: 0x88CBA, size: 0x8, addend: 0x0, symName: _block_destroy_helper, symObjAddr: 0x768, symBinAddr: 0x13F08, symSize: 0x8 }
-  - { offsetInCU: 0x329, offset: 0x88CCE, size: 0x8, addend: 0x0, symName: '_$s8Dispatch0A13WorkItemFlagsVACs10SetAlgebraAAWl', symObjAddr: 0x770, symBinAddr: 0x13F10, symSize: 0x48 }
-  - { offsetInCU: 0x33D, offset: 0x88CE2, size: 0x8, addend: 0x0, symName: '_$sSay8Dispatch0A13WorkItemFlagsVGSayxGSTsWl', symObjAddr: 0x7F8, symBinAddr: 0x13F58, symSize: 0x4C }
-  - { offsetInCU: 0x351, offset: 0x88CF6, size: 0x8, addend: 0x0, symName: ___swift_instantiateConcreteTypeFromMangledNameAbstract, symObjAddr: 0x844, symBinAddr: 0x13FA4, symSize: 0x44 }
-  - { offsetInCU: 0x365, offset: 0x88D0A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_yyScMYccfU0_TA', symObjAddr: 0x8C4, symBinAddr: 0x13FE8, symSize: 0x24 }
-  - { offsetInCU: 0x399, offset: 0x88D3E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_yyScMYccfU_TA', symObjAddr: 0x90C, symBinAddr: 0x14030, symSize: 0x24 }
-  - { offsetInCU: 0x52E, offset: 0x88ED3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF4SyncySbs5Int64V_So7UIImageCtFZ', symObjAddr: 0x138, symBinAddr: 0x138D8, symSize: 0x4 }
-  - { offsetInCU: 0x55C, offset: 0x88F01, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF4SyncySbs5Int64V_So7UIImageCtFZ', symObjAddr: 0x138, symBinAddr: 0x138D8, symSize: 0x4 }
-  - { offsetInCU: 0x5BB, offset: 0x88F60, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZ', symObjAddr: 0x180, symBinAddr: 0x13920, symSize: 0x4 }
-  - { offsetInCU: 0x5CF, offset: 0x88F74, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_', symObjAddr: 0x184, symBinAddr: 0x13924, symSize: 0x228 }
-  - { offsetInCU: 0x6A8, offset: 0x8904D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCACycfC', symObjAddr: 0x42C, symBinAddr: 0x13BCC, symSize: 0x20 }
-  - { offsetInCU: 0x6BC, offset: 0x89061, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCACycfc', symObjAddr: 0x44C, symBinAddr: 0x13BEC, symSize: 0x30 }
-  - { offsetInCU: 0x6F2, offset: 0x89097, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCfD', symObjAddr: 0x4B8, symBinAddr: 0x13C58, symSize: 0x30 }
-  - { offsetInCU: 0x27, offset: 0x8913D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfC', symObjAddr: 0x0, symBinAddr: 0x14068, symSize: 0x20 }
-  - { offsetInCU: 0x77, offset: 0x8918D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfcTo', symObjAddr: 0x70, symBinAddr: 0x140D8, symSize: 0x3C }
-  - { offsetInCU: 0xC9, offset: 0x891DF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCMa', symObjAddr: 0x50, symBinAddr: 0x140B8, symSize: 0x20 }
-  - { offsetInCU: 0x214, offset: 0x8932A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfC', symObjAddr: 0x0, symBinAddr: 0x14068, symSize: 0x20 }
-  - { offsetInCU: 0x228, offset: 0x8933E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfc', symObjAddr: 0x20, symBinAddr: 0x14088, symSize: 0x30 }
-  - { offsetInCU: 0x264, offset: 0x8937A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCfD', symObjAddr: 0xAC, symBinAddr: 0x14114, symSize: 0x30 }
-  - { offsetInCU: 0x26, offset: 0x893C3, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_frombytes_vartime, symObjAddr: 0x0, symBinAddr: 0x2B1E9C, symSize: 0x265C }
-  - { offsetInCU: 0x40, offset: 0x893DD, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_k25519Precomp, symObjAddr: 0x9E20, symBinAddr: 0x9951C0, symSize: 0x0 }
-  - { offsetInCU: 0x92, offset: 0x8942F, size: 0x8, addend: 0x0, symName: _d, symObjAddr: 0xFE20, symBinAddr: 0x99B1C0, symSize: 0x0 }
-  - { offsetInCU: 0xF6, offset: 0x89493, size: 0x8, addend: 0x0, symName: _sqrtm1, symObjAddr: 0xFE48, symBinAddr: 0x99B1E8, symSize: 0x0 }
-  - { offsetInCU: 0x10C, offset: 0x894A9, size: 0x8, addend: 0x0, symName: _d2, symObjAddr: 0x10250, symBinAddr: 0x99B5F0, symSize: 0x0 }
-  - { offsetInCU: 0x123, offset: 0x894C0, size: 0x8, addend: 0x0, symName: _Bi, symObjAddr: 0xFE90, symBinAddr: 0x99B230, symSize: 0x0 }
-  - { offsetInCU: 0x9C2, offset: 0x89D5F, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_frombytes_vartime, symObjAddr: 0x0, symBinAddr: 0x2B1E9C, symSize: 0x265C }
-  - { offsetInCU: 0x45D1, offset: 0x8D96E, size: 0x8, addend: 0x0, symName: _fe_frombytes, symObjAddr: 0x265C, symBinAddr: 0x2B44F8, symSize: 0x134 }
-  - { offsetInCU: 0x46F7, offset: 0x8DA94, size: 0x8, addend: 0x0, symName: _fe_mul_impl, symObjAddr: 0x9954, symBinAddr: 0x2BB7F0, symSize: 0x21C }
-  - { offsetInCU: 0x4926, offset: 0x8DCC3, size: 0x8, addend: 0x0, symName: _fe_tobytes, symObjAddr: 0x4FE0, symBinAddr: 0x2B6E7C, symSize: 0x1B8 }
-  - { offsetInCU: 0x5313, offset: 0x8E6B0, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_scalarmult_base, symObjAddr: 0x2790, symBinAddr: 0x2B462C, symSize: 0x5BC }
-  - { offsetInCU: 0x5F76, offset: 0x8F313, size: 0x8, addend: 0x0, symName: _table_select, symObjAddr: 0x2D4C, symBinAddr: 0x2B4BE8, symSize: 0x7F8 }
-  - { offsetInCU: 0x642E, offset: 0x8F7CB, size: 0x8, addend: 0x0, symName: _ge_madd, symObjAddr: 0x3544, symBinAddr: 0x2B53E0, symSize: 0x208 }
-  - { offsetInCU: 0x69FC, offset: 0x8FD99, size: 0x8, addend: 0x0, symName: _ge_p2_dbl, symObjAddr: 0x374C, symBinAddr: 0x2B55E8, symSize: 0x7B4 }
-  - { offsetInCU: 0x77D5, offset: 0x90B72, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_sc_reduce, symObjAddr: 0x3F00, symBinAddr: 0x2B5D9C, symSize: 0x634 }
-  - { offsetInCU: 0x8196, offset: 0x91533, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_scalar_mult_generic_masked, symObjAddr: 0x4534, symBinAddr: 0x2B63D0, symSize: 0xAAC }
-  - { offsetInCU: 0x9567, offset: 0x92904, size: 0x8, addend: 0x0, symName: _fe_loose_invert, symObjAddr: 0x529C, symBinAddr: 0x2B7138, symSize: 0x23F8 }
-  - { offsetInCU: 0xCAB8, offset: 0x95E55, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_public_from_private_generic_masked, symObjAddr: 0x5198, symBinAddr: 0x2B7034, symSize: 0x104 }
-  - { offsetInCU: 0xCD20, offset: 0x960BD, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_invert, symObjAddr: 0x7694, symBinAddr: 0x2B9530, symSize: 0x30 }
-  - { offsetInCU: 0xCE11, offset: 0x961AE, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_isnegative, symObjAddr: 0x76C4, symBinAddr: 0x2B9560, symSize: 0x58 }
-  - { offsetInCU: 0xCE86, offset: 0x96223, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_mul_ttt, symObjAddr: 0x771C, symBinAddr: 0x2B95B8, symSize: 0x4 }
-  - { offsetInCU: 0xCECE, offset: 0x9626B, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_mul_ttt, symObjAddr: 0x771C, symBinAddr: 0x2B95B8, symSize: 0x4 }
-  - { offsetInCU: 0xCEFD, offset: 0x9629A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_mul_ttt, symObjAddr: 0x771C, symBinAddr: 0x2B95B8, symSize: 0x4 }
-  - { offsetInCU: 0xCF21, offset: 0x962BE, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_neg, symObjAddr: 0x7720, symBinAddr: 0x2B95BC, symSize: 0x8C }
-  - { offsetInCU: 0xD056, offset: 0x963F3, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_tobytes, symObjAddr: 0x77AC, symBinAddr: 0x2B9648, symSize: 0x4 }
-  - { offsetInCU: 0xD08F, offset: 0x9642C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_tobytes, symObjAddr: 0x77AC, symBinAddr: 0x2B9648, symSize: 0x4 }
-  - { offsetInCU: 0xD328, offset: 0x966C5, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_double_scalarmult_vartime, symObjAddr: 0x77B0, symBinAddr: 0x2B964C, symSize: 0x15D8 }
-  - { offsetInCU: 0x10671, offset: 0x99A0E, size: 0x8, addend: 0x0, symName: _x25519_ge_add, symObjAddr: 0x9B70, symBinAddr: 0x2BBA0C, symSize: 0x218 }
-  - { offsetInCU: 0x10CA3, offset: 0x9A040, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_sc_mask, symObjAddr: 0x8D88, symBinAddr: 0x2BAC24, symSize: 0x20 }
-  - { offsetInCU: 0x11140, offset: 0x9A4DD, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_sc_muladd, symObjAddr: 0x8DA8, symBinAddr: 0x2BAC44, symSize: 0xBAC }
-  - { offsetInCU: 0x26, offset: 0x9B2A8, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_from_montgomery_in_place, symObjAddr: 0x0, symBinAddr: 0x2BBC24, symSize: 0x1F4 }
-  - { offsetInCU: 0x1D2, offset: 0x9B454, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_from_montgomery_in_place, symObjAddr: 0x0, symBinAddr: 0x2BBC24, symSize: 0x1F4 }
-  - { offsetInCU: 0x26, offset: 0x9B6EF, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_neg_inv_mod_r_u64, symObjAddr: 0x0, symBinAddr: 0x2BBE18, symSize: 0x3C }
-  - { offsetInCU: 0x34, offset: 0x9B6FD, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_neg_inv_mod_r_u64, symObjAddr: 0x0, symBinAddr: 0x2BBE18, symSize: 0x3C }
-  - { offsetInCU: 0x26, offset: 0x9B80D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_little_endian_bytes_from_scalar, symObjAddr: 0x0, symBinAddr: 0x2BBE54, symSize: 0x98 }
-  - { offsetInCU: 0x34, offset: 0x9B81B, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_little_endian_bytes_from_scalar, symObjAddr: 0x0, symBinAddr: 0x2BBE54, symSize: 0x98 }
-  - { offsetInCU: 0x86, offset: 0x9B97E, size: 0x8, addend: 0x0, symName: _Q_N0, symObjAddr: 0x1100, symBinAddr: 0x99B6A0, symSize: 0x0 }
-  - { offsetInCU: 0xB8, offset: 0x9B9B0, size: 0x8, addend: 0x0, symName: _Q, symObjAddr: 0x1090, symBinAddr: 0x99B630, symSize: 0x0 }
-  - { offsetInCU: 0xDA, offset: 0x9B9D2, size: 0x8, addend: 0x0, symName: _N, symObjAddr: 0x10C0, symBinAddr: 0x99B660, symSize: 0x0 }
-  - { offsetInCU: 0xF0, offset: 0x9B9E8, size: 0x8, addend: 0x0, symName: _N_N0, symObjAddr: 0x10F0, symBinAddr: 0x99B690, symSize: 0x0 }
-  - { offsetInCU: 0x3B7, offset: 0x9BCAF, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_elem_mul_mont, symObjAddr: 0x100, symBinAddr: 0x2BBEEC, symSize: 0x18 }
-  - { offsetInCU: 0x3FB, offset: 0x9BCF3, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_elem_mul_mont, symObjAddr: 0x100, symBinAddr: 0x2BBEEC, symSize: 0x18 }
-  - { offsetInCU: 0x594, offset: 0x9BE8C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_scalar_mul_mont, symObjAddr: 0x1F8, symBinAddr: 0x2BBF04, symSize: 0x18 }
-  - { offsetInCU: 0x63F, offset: 0x9BF37, size: 0x8, addend: 0x0, symName: _nistz384_point_double, symObjAddr: 0x290, symBinAddr: 0x2BBF1C, symSize: 0x320 }
-  - { offsetInCU: 0x1173, offset: 0x9CA6B, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_point_add, symObjAddr: 0x5B0, symBinAddr: 0x2BC23C, symSize: 0xAC }
-  - { offsetInCU: 0x1469, offset: 0x9CD61, size: 0x8, addend: 0x0, symName: _nistz384_point_add, symObjAddr: 0x65C, symBinAddr: 0x2BC2E8, symSize: 0x500 }
-  - { offsetInCU: 0x2666, offset: 0x9DF5E, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_point_mul, symObjAddr: 0xB5C, symBinAddr: 0x2BC7E8, symSize: 0x2C8 }
-  - { offsetInCU: 0x2CB5, offset: 0x9E5AD, size: 0x8, addend: 0x0, symName: _p384_point_select_w5, symObjAddr: 0xE24, symBinAddr: 0x2BCAB0, symSize: 0xF4 }
-  - { offsetInCU: 0x2EC7, offset: 0x9E7BF, size: 0x8, addend: 0x0, symName: _add_precomputed_w5, symObjAddr: 0xF18, symBinAddr: 0x2BCBA4, symSize: 0x168 }
-  - { offsetInCU: 0x26, offset: 0x9EAEA, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_zero, symObjAddr: 0x0, symBinAddr: 0x2BCD0C, symSize: 0x38 }
-  - { offsetInCU: 0xFA, offset: 0x9EBBE, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_zero, symObjAddr: 0x0, symBinAddr: 0x2BCD0C, symSize: 0x38 }
-  - { offsetInCU: 0x12C, offset: 0x9EBF0, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_zero, symObjAddr: 0x0, symBinAddr: 0x2BCD0C, symSize: 0x38 }
-  - { offsetInCU: 0x199, offset: 0x9EC5D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_equal, symObjAddr: 0x38, symBinAddr: 0x2BCD44, symSize: 0x3C }
-  - { offsetInCU: 0x1F3, offset: 0x9ECB7, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_equal, symObjAddr: 0x38, symBinAddr: 0x2BCD44, symSize: 0x3C }
-  - { offsetInCU: 0x31B, offset: 0x9EDDF, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_equal_limb, symObjAddr: 0x74, symBinAddr: 0x2BCD80, symSize: 0x5C }
-  - { offsetInCU: 0x517, offset: 0x9EFDB, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_even, symObjAddr: 0xD0, symBinAddr: 0x2BCDDC, symSize: 0x1C }
-  - { offsetInCU: 0x636, offset: 0x9F0FA, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_less_than, symObjAddr: 0xEC, symBinAddr: 0x2BCDF8, symSize: 0x54 }
-  - { offsetInCU: 0x6D9, offset: 0x9F19D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_less_than_limb, symObjAddr: 0x140, symBinAddr: 0x2BCE4C, symSize: 0x4C }
-  - { offsetInCU: 0x8A7, offset: 0x9F36B, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_reduce_once, symObjAddr: 0x18C, symBinAddr: 0x2BCE98, symSize: 0xA8 }
-  - { offsetInCU: 0x90B, offset: 0x9F3CF, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_reduce_once, symObjAddr: 0x18C, symBinAddr: 0x2BCE98, symSize: 0xA8 }
-  - { offsetInCU: 0xBAA, offset: 0x9F66E, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_add_mod, symObjAddr: 0x234, symBinAddr: 0x2BCF40, symSize: 0x110 }
-  - { offsetInCU: 0xC4C, offset: 0x9F710, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_add_mod, symObjAddr: 0x234, symBinAddr: 0x2BCF40, symSize: 0x110 }
-  - { offsetInCU: 0xEDE, offset: 0x9F9A2, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_sub_mod, symObjAddr: 0x344, symBinAddr: 0x2BD050, symSize: 0xB0 }
-  - { offsetInCU: 0xF5E, offset: 0x9FA22, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_sub_mod, symObjAddr: 0x344, symBinAddr: 0x2BD050, symSize: 0xB0 }
-  - { offsetInCU: 0x10E1, offset: 0x9FBA5, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_shl_mod, symObjAddr: 0x3F4, symBinAddr: 0x2BD100, symSize: 0x198 }
-  - { offsetInCU: 0x13AB, offset: 0x9FE6F, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_select_512_32, symObjAddr: 0x58C, symBinAddr: 0x2BD298, symSize: 0x290 }
-  - { offsetInCU: 0x1500, offset: 0x9FFC4, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_window5_split_window, symObjAddr: 0x81C, symBinAddr: 0x2BD528, symSize: 0x18 }
-  - { offsetInCU: 0x1567, offset: 0xA002B, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_window5_unsplit_window, symObjAddr: 0x834, symBinAddr: 0x2BD540, symSize: 0xC }
-  - { offsetInCU: 0x15A0, offset: 0xA0064, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMB_shr, symObjAddr: 0x840, symBinAddr: 0x2BD54C, symSize: 0x8 }
-  - { offsetInCU: 0x1624, offset: 0xA00E8, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_limbs_mul_add_limb, symObjAddr: 0x848, symBinAddr: 0x2BD554, symSize: 0x3C }
-  - { offsetInCU: 0x26, offset: 0xA029B, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_CRYPTO_memcmp, symObjAddr: 0x0, symBinAddr: 0x2BD590, symSize: 0x190 }
-  - { offsetInCU: 0x34, offset: 0xA02A9, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_CRYPTO_memcmp, symObjAddr: 0x0, symBinAddr: 0x2BD590, symSize: 0x190 }
-  - { offsetInCU: 0x34, offset: 0xA03AF, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_OPENSSL_armcap_P, symObjAddr: 0x398, symBinAddr: 0x10CB0D8, symSize: 0x0 }
-  - { offsetInCU: 0x26, offset: 0xA03F1, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul, symObjAddr: 0x0, symBinAddr: 0x2BD720, symSize: 0x388 }
-  - { offsetInCU: 0x76, offset: 0xA0441, size: 0x8, addend: 0x0, symName: _ecp_nistz256_precomputed, symObjAddr: 0x1000, symBinAddr: 0x99C000, symSize: 0x0 }
-  - { offsetInCU: 0xFA, offset: 0xA04C5, size: 0x8, addend: 0x0, symName: _ONE, symObjAddr: 0x26000, symBinAddr: 0x9C1000, symSize: 0x0 }
-  - { offsetInCU: 0x35B, offset: 0xA0726, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul, symObjAddr: 0x0, symBinAddr: 0x2BD720, symSize: 0x388 }
-  - { offsetInCU: 0xC66, offset: 0xA1031, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul_base, symObjAddr: 0x388, symBinAddr: 0x2BDAA8, symSize: 0x204 }
-  - { offsetInCU: 0x1163, offset: 0xA152E, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul_base_vartime, symObjAddr: 0x58C, symBinAddr: 0x2BDCAC, symSize: 0x1BC }
-  - { offsetInCU: 0x10, offset: 0xA1903, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_set_encrypt_key, symObjAddr: 0x0, symBinAddr: 0x2BDE80, symSize: 0x1A0 }
-  - { offsetInCU: 0x50, offset: 0xA1943, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_set_encrypt_key, symObjAddr: 0x0, symBinAddr: 0x2BDE80, symSize: 0x1A0 }
-  - { offsetInCU: 0x5E, offset: 0xA1951, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_encrypt, symObjAddr: 0x1A0, symBinAddr: 0x2BE020, symSize: 0x60 }
-  - { offsetInCU: 0x81, offset: 0xA1974, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_ctr32_encrypt_blocks, symObjAddr: 0x200, symBinAddr: 0x2BE080, symSize: 0x288 }
-  - { offsetInCU: 0x10, offset: 0xA1965, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_init_clmul, symObjAddr: 0x0, symBinAddr: 0x2BE310, symSize: 0x130 }
-  - { offsetInCU: 0x48, offset: 0xA199D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_init_clmul, symObjAddr: 0x0, symBinAddr: 0x2BE310, symSize: 0x130 }
-  - { offsetInCU: 0x5F, offset: 0xA19B4, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_gmult_clmul, symObjAddr: 0x130, symBinAddr: 0x2BE440, symSize: 0x70 }
-  - { offsetInCU: 0x75, offset: 0xA19CA, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_ghash_clmul, symObjAddr: 0x1A0, symBinAddr: 0x2BE4B0, symSize: 0x160 }
-  - { offsetInCU: 0x7A, offset: 0xA19CF, size: 0x8, addend: 0x0, symName: gcm_ghash_v8_4x, symObjAddr: 0x300, symBinAddr: 0x2BE610, symSize: 0x378 }
-  - { offsetInCU: 0x10, offset: 0xA19DD, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ChaCha20_ctr32, symObjAddr: 0x0, symBinAddr: 0x2BE9A0, symSize: 0x3A0 }
-  - { offsetInCU: 0x48, offset: 0xA1A15, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ChaCha20_ctr32, symObjAddr: 0x0, symBinAddr: 0x2BE9A0, symSize: 0x3A0 }
-  - { offsetInCU: 0x4C, offset: 0xA1A19, size: 0x8, addend: 0x0, symName: ChaCha20_neon, symObjAddr: 0x3A0, symBinAddr: 0x2BED40, symSize: 0x6C0 }
-  - { offsetInCU: 0x66, offset: 0xA1A33, size: 0x8, addend: 0x0, symName: ChaCha20_512_neon, symObjAddr: 0xA60, symBinAddr: 0x2BF400, symSize: 0x1138 }
-  - { offsetInCU: 0x50, offset: 0xA1A7F, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_chacha20_poly1305_seal, symObjAddr: 0x140, symBinAddr: 0x2C0680, symSize: 0x1180 }
-  - { offsetInCU: 0x66, offset: 0xA1A95, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_chacha20_poly1305_open, symObjAddr: 0x12C0, symBinAddr: 0x2C1800, symSize: 0x1410 }
-  - { offsetInCU: 0x10, offset: 0xA1A8B, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_mul_mont, symObjAddr: 0x0, symBinAddr: 0x2C2C20, symSize: 0x240 }
-  - { offsetInCU: 0x45, offset: 0xA1AC0, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_mul_mont, symObjAddr: 0x0, symBinAddr: 0x2C2C20, symSize: 0x240 }
-  - { offsetInCU: 0x4D, offset: 0xA1AC8, size: 0x8, addend: 0x0, symName: __bn_sqr8x_mont, symObjAddr: 0x240, symBinAddr: 0x2C2E60, symSize: 0x9E0 }
-  - { offsetInCU: 0x63, offset: 0xA1ADE, size: 0x8, addend: 0x0, symName: __bn_mul4x_mont, symObjAddr: 0xC20, symBinAddr: 0x2C3840, symSize: 0x650 }
-  - { offsetInCU: 0x10, offset: 0xA1AED, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_mul_mont, symObjAddr: 0x0, symBinAddr: 0x2C3EA0, symSize: 0x40 }
-  - { offsetInCU: 0x47, offset: 0xA1B24, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_mul_mont, symObjAddr: 0x0, symBinAddr: 0x2C3EA0, symSize: 0x40 }
-  - { offsetInCU: 0x5D, offset: 0xA1B3A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_sqr_mont, symObjAddr: 0x40, symBinAddr: 0x2C3EE0, symSize: 0x40 }
-  - { offsetInCU: 0x76, offset: 0xA1B53, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ecp_nistz256_neg, symObjAddr: 0x80, symBinAddr: 0x2C3F20, symSize: 0x40 }
-  - { offsetInCU: 0x81, offset: 0xA1B5E, size: 0x8, addend: 0x0, symName: __ecp_nistz256_mul_mont, symObjAddr: 0xC0, symBinAddr: 0x2C3F60, symSize: 0x1E0 }
-  - { offsetInCU: 0x97, offset: 0xA1B74, size: 0x8, addend: 0x0, symName: __ecp_nistz256_sqr_mont, symObjAddr: 0x2A0, symBinAddr: 0x2C4140, symSize: 0x170 }
-  - { offsetInCU: 0xAB, offset: 0xA1B88, size: 0x8, addend: 0x0, symName: __ecp_nistz256_add_to, symObjAddr: 0x410, symBinAddr: 0x2C42B0, symSize: 0x50 }
-  - { offsetInCU: 0xC3, offset: 0xA1BA0, size: 0x8, addend: 0x0, symName: __ecp_nistz256_sub_from, symObjAddr: 0x460, symBinAddr: 0x2C4300, symSize: 0x50 }
-  - { offsetInCU: 0xD9, offset: 0xA1BB6, size: 0x8, addend: 0x0, symName: __ecp_nistz256_sub_morf, symObjAddr: 0x4B0, symBinAddr: 0x2C4350, symSize: 0x50 }
-  - { offsetInCU: 0xEF, offset: 0xA1BCC, size: 0x8, addend: 0x0, symName: __ecp_nistz256_div_by_2, symObjAddr: 0x500, symBinAddr: 0x2C43A0, symSize: 0x60 }
-  - { offsetInCU: 0x111, offset: 0xA1BEE, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_double, symObjAddr: 0x560, symBinAddr: 0x2C4400, symSize: 0x1E0 }
-  - { offsetInCU: 0x124, offset: 0xA1C01, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_add, symObjAddr: 0x740, symBinAddr: 0x2C45E0, symSize: 0x360 }
-  - { offsetInCU: 0x141, offset: 0xA1C1E, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_add_affine, symObjAddr: 0xAA0, symBinAddr: 0x2C4940, symSize: 0x2D0 }
-  - { offsetInCU: 0x156, offset: 0xA1C33, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_scalar_mul_mont, symObjAddr: 0xD70, symBinAddr: 0x2C4C10, symSize: 0x2B0 }
-  - { offsetInCU: 0x170, offset: 0xA1C4D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_scalar_sqr_rep_mont, symObjAddr: 0x1020, symBinAddr: 0x2C4EC0, symSize: 0x250 }
-  - { offsetInCU: 0x184, offset: 0xA1C61, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ecp_nistz256_select_w5, symObjAddr: 0x1270, symBinAddr: 0x2C5110, symSize: 0x60 }
-  - { offsetInCU: 0x19A, offset: 0xA1C77, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ecp_nistz256_select_w7, symObjAddr: 0x12D0, symBinAddr: 0x2C5170, symSize: 0x44 }
-  - { offsetInCU: 0x10, offset: 0xA1C6D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_gcm_enc_kernel, symObjAddr: 0x0, symBinAddr: 0x2C51C0, symSize: 0xB90 }
-  - { offsetInCU: 0x4C, offset: 0xA1CA9, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_gcm_enc_kernel, symObjAddr: 0x0, symBinAddr: 0x2C51C0, symSize: 0xB90 }
-  - { offsetInCU: 0x62, offset: 0xA1CBF, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_gcm_dec_kernel, symObjAddr: 0xB90, symBinAddr: 0x2C5D50, symSize: 0xB98 }
-  - { offsetInCU: 0x10, offset: 0xA1CB9, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha512_block_data_order, symObjAddr: 0x0, symBinAddr: 0x2C6900, symSize: 0xE40 }
-  - { offsetInCU: 0x51, offset: 0xA1CFA, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha512_block_data_order, symObjAddr: 0x0, symBinAddr: 0x2C6900, symSize: 0xE40 }
-  - { offsetInCU: 0x51, offset: 0xA1CFA, size: 0x8, addend: 0x0, symName: sha512_block_armv8, symObjAddr: 0xE40, symBinAddr: 0x2C7740, symSize: 0x7E0 }
-  - { offsetInCU: 0x10, offset: 0xA1D05, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha256_block_data_order, symObjAddr: 0x0, symBinAddr: 0x2C7F40, symSize: 0xE40 }
-  - { offsetInCU: 0x51, offset: 0xA1D46, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha256_block_data_order, symObjAddr: 0x0, symBinAddr: 0x2C7F40, symSize: 0xE40 }
-  - { offsetInCU: 0x51, offset: 0xA1D46, size: 0x8, addend: 0x0, symName: sha256_block_armv8, symObjAddr: 0xE40, symBinAddr: 0x2C8D80, symSize: 0x1F0 }
+  - { offsetInCU: 0x34, offset: 0x77D9B, size: 0x8, addend: 0x0, symName: _CanvasNativeVersionString, symObjAddr: 0x0, symBinAddr: 0x955000, symSize: 0x0 }
+  - { offsetInCU: 0x69, offset: 0x77DD0, size: 0x8, addend: 0x0, symName: _CanvasNativeVersionNumber, symObjAddr: 0x38, symBinAddr: 0x955038, symSize: 0x0 }
+  - { offsetInCU: 0x3F, offset: 0x77E25, size: 0x8, addend: 0x0, symName: ___swift_memcpy16_8, symObjAddr: 0x28, symBinAddr: 0x5268, symSize: 0xC }
+  - { offsetInCU: 0x53, offset: 0x77E39, size: 0x8, addend: 0x0, symName: ___swift_noop_void_return, symObjAddr: 0x34, symBinAddr: 0x5274, symSize: 0x4 }
+  - { offsetInCU: 0x67, offset: 0x77E4D, size: 0x8, addend: 0x0, symName: '_$sSo6CGSizeVwet', symObjAddr: 0x38, symBinAddr: 0x5278, symSize: 0x20 }
+  - { offsetInCU: 0x7B, offset: 0x77E61, size: 0x8, addend: 0x0, symName: '_$sSo6CGSizeVwst', symObjAddr: 0x58, symBinAddr: 0x5298, symSize: 0x28 }
+  - { offsetInCU: 0x8F, offset: 0x77E75, size: 0x8, addend: 0x0, symName: '_$sSo6CGRectVwCP', symObjAddr: 0x94, symBinAddr: 0x52D4, symSize: 0x30 }
+  - { offsetInCU: 0xA3, offset: 0x77E89, size: 0x8, addend: 0x0, symName: ___swift_memcpy32_8, symObjAddr: 0xC4, symBinAddr: 0x5304, symSize: 0xC }
+  - { offsetInCU: 0xB7, offset: 0x77E9D, size: 0x8, addend: 0x0, symName: '_$sSo6CGRectVwet', symObjAddr: 0xD0, symBinAddr: 0x5310, symSize: 0x20 }
+  - { offsetInCU: 0xCB, offset: 0x77EB1, size: 0x8, addend: 0x0, symName: '_$sSo6CGRectVwst', symObjAddr: 0xF0, symBinAddr: 0x5330, symSize: 0x2C }
+  - { offsetInCU: 0x4F, offset: 0x7809A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC11_WriteQueue33_05178D28796EA758448493B56DC45144LLSo011NSOperationE0CSgvpZ', symObjAddr: 0x2AE8, symBinAddr: 0x114FD10, symSize: 0x0 }
+  - { offsetInCU: 0x69, offset: 0x780B4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10_ReadQueue33_05178D28796EA758448493B56DC45144LLSo011NSOperationE0CSgvpZ', symObjAddr: 0x2AF0, symBinAddr: 0x114FD18, symSize: 0x0 }
+  - { offsetInCU: 0x9D, offset: 0x780E8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC19getBytesFromUIImageySo13NSMutableDataCSo0G0CFZTo', symObjAddr: 0x4, symBinAddr: 0x53D4, symSize: 0x38 }
+  - { offsetInCU: 0xF3, offset: 0x7813E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13createPatternys5Int64VAF_So7UIImageCSStFZTo', symObjAddr: 0x40, symBinAddr: 0x5410, symSize: 0x70 }
+  - { offsetInCU: 0x144, offset: 0x7818F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC25loadImageAssetWithContextySbs5Int64V_So7UIImageCtFZTo', symObjAddr: 0xB4, symBinAddr: 0x5484, symSize: 0x44 }
+  - { offsetInCU: 0x19F, offset: 0x781EA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dyys5Int64V_So7UIImageCS2ftFZTo', symObjAddr: 0xFC, symBinAddr: 0x54CC, symSize: 0x50 }
+  - { offsetInCU: 0x204, offset: 0x7824F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dy2dw2dhys5Int64V_So7UIImageCS4ftFZTo', symObjAddr: 0x150, symBinAddr: 0x5520, symSize: 0x68 }
+  - { offsetInCU: 0x27D, offset: 0x782C8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2sx2sy2sw2sh2dx2dy2dw2dhys5Int64V_So7UIImageCS8ftFZTo', symObjAddr: 0x1BC, symBinAddr: 0x558C, symSize: 0x98 }
+  - { offsetInCU: 0x2DA, offset: 0x78325, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23initWebGPUWithViewLayerys5Int64VAF_AFs6UInt32VAHtFZTo', symObjAddr: 0x258, symBinAddr: 0x5628, symSize: 0x14 }
+  - { offsetInCU: 0x35C, offset: 0x783A7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC18initWebGPUWithViewys5Int64VAF_AFs6UInt32VAHtFZTo', symObjAddr: 0x270, symBinAddr: 0x5640, symSize: 0x14 }
+  - { offsetInCU: 0x40B, offset: 0x78456, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14initGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbtFZTo', symObjAddr: 0x2C8, symBinAddr: 0x5698, symSize: 0x50 }
+  - { offsetInCU: 0x4DC, offset: 0x78527, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC20initSharedGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbAFtFZTo', symObjAddr: 0x364, symBinAddr: 0x5734, symSize: 0x58 }
+  - { offsetInCU: 0x5B6, offset: 0x78601, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC24initGLWithWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbtFZTo', symObjAddr: 0x404, symBinAddr: 0x57D4, symSize: 0x58 }
+  - { offsetInCU: 0x695, offset: 0x786E0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC26initSharedGLWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbAFtFZTo', symObjAddr: 0x4AC, symBinAddr: 0x587C, symSize: 0x60 }
+  - { offsetInCU: 0x741, offset: 0x7878C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15resize2DContextyys5Int64V_S2ftFZTo', symObjAddr: 0x510, symBinAddr: 0x58E0, symSize: 0x8 }
+  - { offsetInCU: 0x7AA, offset: 0x787F5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14flush2DContextyys5Int64VFZTo', symObjAddr: 0x51C, symBinAddr: 0x58EC, symSize: 0x8 }
+  - { offsetInCU: 0x801, offset: 0x7884C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC7flushGLySbs5Int64VFZTo', symObjAddr: 0x538, symBinAddr: 0x5908, symSize: 0x8 }
+  - { offsetInCU: 0x858, offset: 0x788A3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9releaseGLyys5Int64VFZTo', symObjAddr: 0x544, symBinAddr: 0x5914, symSize: 0x8 }
+  - { offsetInCU: 0x8AF, offset: 0x788FA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC12getGLPointerys5Int64VAFFZTo', symObjAddr: 0x550, symBinAddr: 0x5920, symSize: 0x8 }
+  - { offsetInCU: 0x906, offset: 0x78951, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC16releaseGLPointeryys5Int64VFZTo', symObjAddr: 0x55C, symBinAddr: 0x592C, symSize: 0x8 }
+  - { offsetInCU: 0x985, offset: 0x789D0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15create2DContextys5Int64VAF_s5Int32VAHSbSfA2HSfAHtFZTo', symObjAddr: 0x56C, symBinAddr: 0x593C, symSize: 0x24 }
+  - { offsetInCU: 0xA36, offset: 0x78A81, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23updateGLSurfaceWithViewyys5Int64V_s5Int32VAhFtFZTo', symObjAddr: 0x594, symBinAddr: 0x5964, symSize: 0x14 }
+  - { offsetInCU: 0xAA9, offset: 0x78AF4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC6test2Dyys5Int64VFZTo', symObjAddr: 0x5AC, symBinAddr: 0x597C, symSize: 0x8 }
+  - { offsetInCU: 0xB00, offset: 0x78B4B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13testToDataURLySSs5Int64VFZTo', symObjAddr: 0x60C, symBinAddr: 0x59DC, symSize: 0x74 }
+  - { offsetInCU: 0xB8B, offset: 0x78BD6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZTo', symObjAddr: 0x814, symBinAddr: 0x5BE4, symSize: 0xA0 }
+  - { offsetInCU: 0xBDC, offset: 0x78C27, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZTo', symObjAddr: 0xB1C, symBinAddr: 0x5EEC, symSize: 0x98 }
+  - { offsetInCU: 0xC2D, offset: 0x78C78, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZTo', symObjAddr: 0xE70, symBinAddr: 0x6240, symSize: 0x98 }
+  - { offsetInCU: 0xC89, offset: 0x78CD4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZTo', symObjAddr: 0x1298, symBinAddr: 0x6668, symSize: 0xD8 }
+  - { offsetInCU: 0xCD1, offset: 0x78D1C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC32getPixelsPerInchForCurrentDeviceSSyFZTo', symObjAddr: 0x1374, symBinAddr: 0x6744, symSize: 0x34 }
+  - { offsetInCU: 0xD31, offset: 0x78D7C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCACycfcTo', symObjAddr: 0x13F8, symBinAddr: 0x67C8, symSize: 0x3C }
+  - { offsetInCU: 0xD82, offset: 0x78DCD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC19getBytesFromUIImageySo13NSMutableDataCSo0G0CFZTf4nd_n', symObjAddr: 0x1468, symBinAddr: 0x6838, symSize: 0x2AC }
+  - { offsetInCU: 0xFB6, offset: 0x79001, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13createPatternys5Int64VAF_So7UIImageCSStFZTf4nnnd_n', symObjAddr: 0x1714, symBinAddr: 0x6AE4, symSize: 0x264 }
+  - { offsetInCU: 0x11B0, offset: 0x791FB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC25loadImageAssetWithContextySbs5Int64V_So7UIImageCtFZTf4nnd_n', symObjAddr: 0x1978, symBinAddr: 0x6D48, symSize: 0xEC }
+  - { offsetInCU: 0x12AD, offset: 0x792F8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dyys5Int64V_So7UIImageCS2ftFZTf4nnnnd_n', symObjAddr: 0x1A64, symBinAddr: 0x6E34, symSize: 0x1B4 }
+  - { offsetInCU: 0x1422, offset: 0x7946D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dy2dw2dhys5Int64V_So7UIImageCS4ftFZTf4nnnnnnd_n', symObjAddr: 0x1C18, symBinAddr: 0x6FE8, symSize: 0x1CC }
+  - { offsetInCU: 0x15B7, offset: 0x79602, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2sx2sy2sw2sh2dx2dy2dw2dhys5Int64V_So7UIImageCS8ftFZTf4nnnnnnnnnnd_n', symObjAddr: 0x1DE4, symBinAddr: 0x71B4, symSize: 0x1E0 }
+  - { offsetInCU: 0x17A3, offset: 0x797EE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZTf4nnnd_n', symObjAddr: 0x1FC4, symBinAddr: 0x7394, symSize: 0x1B4 }
+  - { offsetInCU: 0x186D, offset: 0x798B8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZTf4nnnnd_n', symObjAddr: 0x231C, symBinAddr: 0x76EC, symSize: 0x1D4 }
+  - { offsetInCU: 0x194E, offset: 0x79999, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC32getPixelsPerInchForCurrentDeviceSSyFZTf4d_n', symObjAddr: 0x24F0, symBinAddr: 0x78C0, symSize: 0x114 }
+  - { offsetInCU: 0x19F9, offset: 0x79A44, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgACIeyByy_SSSgADIeggg_TR', symObjAddr: 0x8B4, symBinAddr: 0x5C84, symSize: 0x78 }
+  - { offsetInCU: 0x1A11, offset: 0x79A5C, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgSo6NSDataCSgIeyByy_SSSgAFIeggg_TR', symObjAddr: 0xBB4, symBinAddr: 0x5F84, symSize: 0x54 }
+  - { offsetInCU: 0x1A7E, offset: 0x79AC9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCfETo', symObjAddr: 0x1464, symBinAddr: 0x6834, symSize: 0x4 }
+  - { offsetInCU: 0x1B09, offset: 0x79B54, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCMa', symObjAddr: 0x2604, symBinAddr: 0x79D4, symSize: 0x20 }
+  - { offsetInCU: 0x1B1D, offset: 0x79B68, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgACIeyByy_SSSgADIeggg_TRTA', symObjAddr: 0x2648, symBinAddr: 0x7A18, symSize: 0x8 }
+  - { offsetInCU: 0x1B3C, offset: 0x79B87, size: 0x8, addend: 0x0, symName: '_$sSo7NSErrorCSg10ObjectiveC8ObjCBoolVIeyByy_ACSbIeggy_TRTA', symObjAddr: 0x2650, symBinAddr: 0x7A20, symSize: 0x18 }
+  - { offsetInCU: 0x1B65, offset: 0x79BB0, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgSo6NSDataCSgIeyByy_SSSgAFIeggg_TRTA', symObjAddr: 0x2668, symBinAddr: 0x7A38, symSize: 0x8 }
+  - { offsetInCU: 0x1B79, offset: 0x79BC4, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCMa', symObjAddr: 0x2670, symBinAddr: 0x7A40, symSize: 0x3C }
+  - { offsetInCU: 0x1B8D, offset: 0x79BD8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZyyYbcfU_TA', symObjAddr: 0x26F0, symBinAddr: 0x7AC0, symSize: 0x34 }
+  - { offsetInCU: 0x1BA1, offset: 0x79BEC, size: 0x8, addend: 0x0, symName: _block_copy_helper, symObjAddr: 0x2724, symBinAddr: 0x7AF4, symSize: 0x10 }
+  - { offsetInCU: 0x1BB5, offset: 0x79C00, size: 0x8, addend: 0x0, symName: _block_destroy_helper, symObjAddr: 0x2734, symBinAddr: 0x7B04, symSize: 0x8 }
+  - { offsetInCU: 0x1BC9, offset: 0x79C14, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZyyYbcfU_yyYbcfU0_TA', symObjAddr: 0x2760, symBinAddr: 0x7B30, symSize: 0x40 }
+  - { offsetInCU: 0x1BFD, offset: 0x79C48, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZyyYbcfU_yyYbcfU0_TA', symObjAddr: 0x27E4, symBinAddr: 0x7BB4, symSize: 0x40 }
+  - { offsetInCU: 0x1C3B, offset: 0x79C86, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZyyYbcfU_yyYbcfU_TA', symObjAddr: 0x2824, symBinAddr: 0x7BF4, symSize: 0x28 }
+  - { offsetInCU: 0x1C6F, offset: 0x79CBA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZyyYbcfU_yyYbcfU_TA', symObjAddr: 0x28A4, symBinAddr: 0x7C74, symSize: 0x3C }
+  - { offsetInCU: 0x1CA3, offset: 0x79CEE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZyyYbcfU_yyYbcfU0_TA', symObjAddr: 0x290C, symBinAddr: 0x7CDC, symSize: 0x30 }
+  - { offsetInCU: 0x1CDF, offset: 0x79D2A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZyyYbcfU_TA', symObjAddr: 0x2978, symBinAddr: 0x7D48, symSize: 0x10 }
+  - { offsetInCU: 0x1CF3, offset: 0x79D3E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZyyYbcfU_yyYbcfU_TA', symObjAddr: 0x2988, symBinAddr: 0x7D58, symSize: 0x40 }
+  - { offsetInCU: 0x21C0, offset: 0x7A20B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC19getBytesFromUIImageySo13NSMutableDataCSo0G0CFZ', symObjAddr: 0x0, symBinAddr: 0x53D0, symSize: 0x4 }
+  - { offsetInCU: 0x21DB, offset: 0x7A226, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x3C, symBinAddr: 0x540C, symSize: 0x4 }
+  - { offsetInCU: 0x21F6, offset: 0x7A241, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC25loadImageAssetWithContextySbs5Int64V_So7UIImageCtFZ', symObjAddr: 0xB0, symBinAddr: 0x5480, symSize: 0x4 }
+  - { offsetInCU: 0x2217, offset: 0x7A262, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dyys5Int64V_So7UIImageCS2ftFZ', symObjAddr: 0xF8, symBinAddr: 0x54C8, symSize: 0x4 }
+  - { offsetInCU: 0x2232, offset: 0x7A27D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dy2dw2dhys5Int64V_So7UIImageCS4ftFZ', symObjAddr: 0x14C, symBinAddr: 0x551C, symSize: 0x4 }
+  - { offsetInCU: 0x224D, offset: 0x7A298, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2sx2sy2sw2sh2dx2dy2dw2dhys5Int64V_So7UIImageCS8ftFZ', symObjAddr: 0x1B8, symBinAddr: 0x5588, symSize: 0x4 }
+  - { offsetInCU: 0x2268, offset: 0x7A2B3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23initWebGPUWithViewLayerys5Int64VAF_AFs6UInt32VAHtFZ', symObjAddr: 0x254, symBinAddr: 0x5624, symSize: 0x4 }
+  - { offsetInCU: 0x22F6, offset: 0x7A341, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC18initWebGPUWithViewys5Int64VAF_AFs6UInt32VAHtFZ', symObjAddr: 0x26C, symBinAddr: 0x563C, symSize: 0x4 }
+  - { offsetInCU: 0x2375, offset: 0x7A3C0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14initGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbtFZ', symObjAddr: 0x284, symBinAddr: 0x5654, symSize: 0x44 }
+  - { offsetInCU: 0x24B3, offset: 0x7A4FE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC20initSharedGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbAFtFZ', symObjAddr: 0x318, symBinAddr: 0x56E8, symSize: 0x4C }
+  - { offsetInCU: 0x25FC, offset: 0x7A647, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC24initGLWithWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbtFZ', symObjAddr: 0x3BC, symBinAddr: 0x578C, symSize: 0x48 }
+  - { offsetInCU: 0x2744, offset: 0x7A78F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC26initSharedGLWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbAFtFZ', symObjAddr: 0x45C, symBinAddr: 0x582C, symSize: 0x50 }
+  - { offsetInCU: 0x28A1, offset: 0x7A8EC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15resize2DContextyys5Int64V_S2ftFZ', symObjAddr: 0x50C, symBinAddr: 0x58DC, symSize: 0x4 }
+  - { offsetInCU: 0x2913, offset: 0x7A95E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14flush2DContextyys5Int64VFZ', symObjAddr: 0x518, symBinAddr: 0x58E8, symSize: 0x4 }
+  - { offsetInCU: 0x2956, offset: 0x7A9A1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC7flushGLySbs5Int64VFZ', symObjAddr: 0x524, symBinAddr: 0x58F4, symSize: 0x14 }
+  - { offsetInCU: 0x299B, offset: 0x7A9E6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9releaseGLyys5Int64VFZ', symObjAddr: 0x540, symBinAddr: 0x5910, symSize: 0x4 }
+  - { offsetInCU: 0x29DE, offset: 0x7AA29, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC12getGLPointerys5Int64VAFFZ', symObjAddr: 0x54C, symBinAddr: 0x591C, symSize: 0x4 }
+  - { offsetInCU: 0x2A21, offset: 0x7AA6C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC16releaseGLPointeryys5Int64VFZ', symObjAddr: 0x558, symBinAddr: 0x5928, symSize: 0x4 }
+  - { offsetInCU: 0x2A64, offset: 0x7AAAF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15create2DContextys5Int64VAF_s5Int32VAHSbSfA2HSfAHtFZ', symObjAddr: 0x564, symBinAddr: 0x5934, symSize: 0x8 }
+  - { offsetInCU: 0x2B4B, offset: 0x7AB96, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23updateGLSurfaceWithViewyys5Int64V_s5Int32VAhFtFZ', symObjAddr: 0x590, symBinAddr: 0x5960, symSize: 0x4 }
+  - { offsetInCU: 0x2BCA, offset: 0x7AC15, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC6test2Dyys5Int64VFZ', symObjAddr: 0x5A8, symBinAddr: 0x5978, symSize: 0x4 }
+  - { offsetInCU: 0x2C0D, offset: 0x7AC58, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13testToDataURLySSs5Int64VFZ', symObjAddr: 0x5B4, symBinAddr: 0x5984, symSize: 0x58 }
+  - { offsetInCU: 0x2CCE, offset: 0x7AD19, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZ', symObjAddr: 0x680, symBinAddr: 0x5A50, symSize: 0x4 }
+  - { offsetInCU: 0x2CE2, offset: 0x7AD2D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZyyYbcfU_', symObjAddr: 0x684, symBinAddr: 0x5A54, symSize: 0x190 }
+  - { offsetInCU: 0x2D82, offset: 0x7ADCD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZ', symObjAddr: 0x92C, symBinAddr: 0x5CFC, symSize: 0x2C }
+  - { offsetInCU: 0x2D96, offset: 0x7ADE1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZyyYbcfU_', symObjAddr: 0x958, symBinAddr: 0x5D28, symSize: 0x1C4 }
+  - { offsetInCU: 0x2E80, offset: 0x7AECB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZ', symObjAddr: 0xC08, symBinAddr: 0x5FD8, symSize: 0x2C }
+  - { offsetInCU: 0x2E94, offset: 0x7AEDF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZyyYbcfU_', symObjAddr: 0xC34, symBinAddr: 0x6004, symSize: 0x23C }
+  - { offsetInCU: 0x2F48, offset: 0x7AF93, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZ', symObjAddr: 0xF08, symBinAddr: 0x62D8, symSize: 0x4 }
+  - { offsetInCU: 0x2F5C, offset: 0x7AFA7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZyyYbcfU_', symObjAddr: 0xF0C, symBinAddr: 0x62DC, symSize: 0x38C }
+  - { offsetInCU: 0x31F3, offset: 0x7B23E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC32getPixelsPerInchForCurrentDeviceSSyFZ', symObjAddr: 0x1370, symBinAddr: 0x6740, symSize: 0x4 }
+  - { offsetInCU: 0x320E, offset: 0x7B259, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCACycfC', symObjAddr: 0x13A8, symBinAddr: 0x6778, symSize: 0x20 }
+  - { offsetInCU: 0x3222, offset: 0x7B26D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCACycfc', symObjAddr: 0x13C8, symBinAddr: 0x6798, symSize: 0x30 }
+  - { offsetInCU: 0x3258, offset: 0x7B2A3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCfD', symObjAddr: 0x1434, symBinAddr: 0x6804, symSize: 0x30 }
+  - { offsetInCU: 0x4F, offset: 0x7B4DB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19shared_context_view33_508084857CA7D194CA72FEB80DD78002LLSo7GLKViewCvpZ', symObjAddr: 0x55B0, symBinAddr: 0x114FD50, symSize: 0x0 }
+  - { offsetInCU: 0x69, offset: 0x7B4F5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15_shared_context33_508084857CA7D194CA72FEB80DD78002LLs5Int64VvpZ', symObjAddr: 0x55B8, symBinAddr: 0x114FD58, symSize: 0x0 }
+  - { offsetInCU: 0x83, offset: 0x7B50F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5storeSo19NSMutableDictionaryCvpZ', symObjAddr: 0x55C0, symBinAddr: 0x114FD60, symSize: 0x0 }
+  - { offsetInCU: 0x9D, offset: 0x7B529, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5views33_508084857CA7D194CA72FEB80DD78002LLSo10NSMapTableCySo8NSStringCACGvpZ', symObjAddr: 0x55C8, symBinAddr: 0x114FD68, symSize: 0x0 }
+  - { offsetInCU: 0xAB, offset: 0x7B537, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19shared_context_view33_508084857CA7D194CA72FEB80DD78002LL_WZ', symObjAddr: 0x0, symBinAddr: 0x7E80, symSize: 0x40 }
+  - { offsetInCU: 0xF0, offset: 0x7B57C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5store_WZ', symObjAddr: 0x40, symBinAddr: 0x7EC0, symSize: 0x30 }
+  - { offsetInCU: 0x135, offset: 0x7B5C1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5views33_508084857CA7D194CA72FEB80DD78002LL_WZ', symObjAddr: 0xA8, symBinAddr: 0x7F28, symSize: 0x40 }
+  - { offsetInCU: 0x187, offset: 0x7B613, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC3ptrSvSgvgTo', symObjAddr: 0x194, symBinAddr: 0x8014, symSize: 0x10 }
+  - { offsetInCU: 0x1A7, offset: 0x7B633, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC3ptrSvSgvgTo', symObjAddr: 0x194, symBinAddr: 0x8014, symSize: 0x10 }
+  - { offsetInCU: 0x1DD, offset: 0x7B669, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC3ptrSvSgvsTo', symObjAddr: 0x1A4, symBinAddr: 0x8024, symSize: 0x10 }
+  - { offsetInCU: 0x1FD, offset: 0x7B689, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC3ptrSvSgvsTo', symObjAddr: 0x1A4, symBinAddr: 0x8024, symSize: 0x10 }
+  - { offsetInCU: 0x236, offset: 0x7B6C2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6mtlPtrSvSgvgTo', symObjAddr: 0x1B4, symBinAddr: 0x8034, symSize: 0x10 }
+  - { offsetInCU: 0x256, offset: 0x7B6E2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6mtlPtrSvSgvgTo', symObjAddr: 0x1B4, symBinAddr: 0x8034, symSize: 0x10 }
+  - { offsetInCU: 0x28C, offset: 0x7B718, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6mtlPtrSvSgvsTo', symObjAddr: 0x1C4, symBinAddr: 0x8044, symSize: 0x10 }
+  - { offsetInCU: 0x2AC, offset: 0x7B738, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6mtlPtrSvSgvsTo', symObjAddr: 0x1C4, symBinAddr: 0x8044, symSize: 0x10 }
+  - { offsetInCU: 0x2E5, offset: 0x7B771, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvgTo', symObjAddr: 0x29C, symBinAddr: 0x811C, symSize: 0x44 }
+  - { offsetInCU: 0x322, offset: 0x7B7AE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvsTo', symObjAddr: 0x324, symBinAddr: 0x81A4, symSize: 0x30 }
+  - { offsetInCU: 0x3B1, offset: 0x7B83D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8nativeGLs5Int64VvgTo', symObjAddr: 0x578, symBinAddr: 0x83F8, symSize: 0x44 }
+  - { offsetInCU: 0x409, offset: 0x7B895, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8nativeGLs5Int64VvsTo', symObjAddr: 0x600, symBinAddr: 0x8480, symSize: 0x48 }
+  - { offsetInCU: 0x464, offset: 0x7B8F0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13nativeContexts5Int64VvgTo', symObjAddr: 0x648, symBinAddr: 0x84C8, symSize: 0x44 }
+  - { offsetInCU: 0x4BC, offset: 0x7B948, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13nativeContexts5Int64VvsTo', symObjAddr: 0x6D0, symBinAddr: 0x8550, symSize: 0x48 }
+  - { offsetInCU: 0x517, offset: 0x7B9A3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15native2DContexts5Int64VvgTo', symObjAddr: 0x718, symBinAddr: 0x8598, symSize: 0x10 }
+  - { offsetInCU: 0x537, offset: 0x7B9C3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15native2DContexts5Int64VvgTo', symObjAddr: 0x718, symBinAddr: 0x8598, symSize: 0x10 }
+  - { offsetInCU: 0x56D, offset: 0x7B9F9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15native2DContexts5Int64VvsTo', symObjAddr: 0x728, symBinAddr: 0x85A8, symSize: 0x10 }
+  - { offsetInCU: 0x58D, offset: 0x7BA19, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15native2DContexts5Int64VvsTo', symObjAddr: 0x728, symBinAddr: 0x85A8, symSize: 0x10 }
+  - { offsetInCU: 0x5C6, offset: 0x7BA52, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7mtlViewSo7MTKViewCvgTo', symObjAddr: 0x738, symBinAddr: 0x85B8, symSize: 0x10 }
+  - { offsetInCU: 0x5E6, offset: 0x7BA72, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7mtlViewSo7MTKViewCvgTo', symObjAddr: 0x738, symBinAddr: 0x85B8, symSize: 0x10 }
+  - { offsetInCU: 0x61E, offset: 0x7BAAA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7mtlViewSo7MTKViewCvsTo', symObjAddr: 0x748, symBinAddr: 0x85C8, symSize: 0x34 }
+  - { offsetInCU: 0x677, offset: 0x7BB03, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7glkViewAA0A7GLKViewCvgTo', symObjAddr: 0x77C, symBinAddr: 0x85FC, symSize: 0x10 }
+  - { offsetInCU: 0x697, offset: 0x7BB23, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7glkViewAA0A7GLKViewCvgTo', symObjAddr: 0x77C, symBinAddr: 0x85FC, symSize: 0x10 }
+  - { offsetInCU: 0x6CF, offset: 0x7BB5B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7glkViewAA0A7GLKViewCvsTo', symObjAddr: 0x78C, symBinAddr: 0x860C, symSize: 0x34 }
+  - { offsetInCU: 0x728, offset: 0x7BBB4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC4is2DSbvgTo', symObjAddr: 0x7C0, symBinAddr: 0x8640, symSize: 0x10 }
+  - { offsetInCU: 0x748, offset: 0x7BBD4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC4is2DSbvgTo', symObjAddr: 0x7C0, symBinAddr: 0x8640, symSize: 0x10 }
+  - { offsetInCU: 0x77E, offset: 0x7BC0A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC4is2DSbvsTo', symObjAddr: 0x7D0, symBinAddr: 0x8650, symSize: 0x10 }
+  - { offsetInCU: 0x79E, offset: 0x7BC2A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC4is2DSbvsTo', symObjAddr: 0x7D0, symBinAddr: 0x8650, symSize: 0x10 }
+  - { offsetInCU: 0x7D7, offset: 0x7BC63, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7isMetalSbvgTo', symObjAddr: 0x7E0, symBinAddr: 0x8660, symSize: 0x10 }
+  - { offsetInCU: 0x7F7, offset: 0x7BC83, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7isMetalSbvgTo', symObjAddr: 0x7E0, symBinAddr: 0x8660, symSize: 0x10 }
+  - { offsetInCU: 0x82D, offset: 0x7BCB9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7isMetalSbvsTo', symObjAddr: 0x7F0, symBinAddr: 0x8670, symSize: 0x10 }
+  - { offsetInCU: 0x84D, offset: 0x7BCD9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7isMetalSbvsTo', symObjAddr: 0x7F0, symBinAddr: 0x8670, symSize: 0x10 }
+  - { offsetInCU: 0x870, offset: 0x7BCFC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18drawingBufferWidthSivgTo', symObjAddr: 0x800, symBinAddr: 0x8680, symSize: 0x34 }
+  - { offsetInCU: 0x8A2, offset: 0x7BD2E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19drawingBufferHeightSivgTo', symObjAddr: 0x904, symBinAddr: 0x8784, symSize: 0x34 }
+  - { offsetInCU: 0x8EA, offset: 0x7BD76, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5widthSfvgTo', symObjAddr: 0xA08, symBinAddr: 0x8888, symSize: 0x20 }
+  - { offsetInCU: 0x952, offset: 0x7BDDE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6heightSfvgTo', symObjAddr: 0xA4C, symBinAddr: 0x88CC, symSize: 0x20 }
+  - { offsetInCU: 0x9F1, offset: 0x7BE7D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11initContextyySS_S4bs5Int32VS5btFTo', symObjAddr: 0xAB4, symBinAddr: 0x8934, symSize: 0xC4 }
+  - { offsetInCU: 0xAB4, offset: 0x7BF40, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17initWebGPUContextyys5Int64VFTo', symObjAddr: 0xD10, symBinAddr: 0x8B90, symSize: 0x30 }
+  - { offsetInCU: 0xB64, offset: 0x7BFF0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC015initContextWithE10AttributesyySS_S4bs5Int32VS5btFTo', symObjAddr: 0x15B0, symBinAddr: 0x9430, symSize: 0xC4 }
+  - { offsetInCU: 0xBCE, offset: 0x7C05A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15create2DContextys5Int64VSb_S3bs5Int32VS5bAHtFTo', symObjAddr: 0x18CC, symBinAddr: 0x974C, symSize: 0xB0 }
+  - { offsetInCU: 0xC0B, offset: 0x7C097, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11forceLayoutyy12CoreGraphics7CGFloatV_AGtFTo', symObjAddr: 0x1A3C, symBinAddr: 0x98BC, symSize: 0xB8 }
+  - { offsetInCU: 0xC83, offset: 0x7C10F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8snapshotySo7UIImageCSgSbFTo', symObjAddr: 0x1BD8, symBinAddr: 0x9A58, symSize: 0x3C }
+  - { offsetInCU: 0xCB6, offset: 0x7C142, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8rendererAA9NSCRenderCSgvgTo', symObjAddr: 0x1C14, symBinAddr: 0x9A94, symSize: 0x10 }
+  - { offsetInCU: 0xCD6, offset: 0x7C162, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8rendererAA9NSCRenderCSgvgTo', symObjAddr: 0x1C14, symBinAddr: 0x9A94, symSize: 0x10 }
+  - { offsetInCU: 0xD10, offset: 0x7C19C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8rendererAA9NSCRenderCSgvsTo', symObjAddr: 0x1C24, symBinAddr: 0x9AA4, symSize: 0x34 }
+  - { offsetInCU: 0xD6B, offset: 0x7C1F7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6renderSbyFTo', symObjAddr: 0x1CA0, symBinAddr: 0x9B20, symSize: 0x48 }
+  - { offsetInCU: 0xE05, offset: 0x7C291, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13context2DTestyys5Int64VFTo', symObjAddr: 0x1D34, symBinAddr: 0x9BB4, symSize: 0x64 }
+  - { offsetInCU: 0xECA, offset: 0x7C356, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC22context2DTestToDataURLySSs5Int64VFTo', symObjAddr: 0x1DF0, symBinAddr: 0x9C70, symSize: 0x94 }
+  - { offsetInCU: 0xF57, offset: 0x7C3E3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC23enterBackgroundListeneryycSgvsTo', symObjAddr: 0x1EC4, symBinAddr: 0x9D44, symSize: 0x6C }
+  - { offsetInCU: 0xFB9, offset: 0x7C445, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC20becomeActiveListeneryycSgvsTo', symObjAddr: 0x1FD4, symBinAddr: 0x9E54, symSize: 0x6C }
+  - { offsetInCU: 0x1016, offset: 0x7C4A2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvgTo', symObjAddr: 0x2040, symBinAddr: 0x9EC0, symSize: 0xB0 }
+  - { offsetInCU: 0x1068, offset: 0x7C4F4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvsTo', symObjAddr: 0x21C0, symBinAddr: 0xA040, symSize: 0x94 }
+  - { offsetInCU: 0x10FA, offset: 0x7C586, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5coderACSgSo7NSCoderC_tcfcTo', symObjAddr: 0x2EAC, symBinAddr: 0xAD2C, symSize: 0x28 }
+  - { offsetInCU: 0x114F, offset: 0x7C5DB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5frameACSo6CGRectV_tcfcTo', symObjAddr: 0x392C, symBinAddr: 0xB7AC, symSize: 0x20 }
+  - { offsetInCU: 0x1182, offset: 0x7C60E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvgTo', symObjAddr: 0x394C, symBinAddr: 0xB7CC, symSize: 0x10 }
+  - { offsetInCU: 0x11A2, offset: 0x7C62E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvgTo', symObjAddr: 0x394C, symBinAddr: 0xB7CC, symSize: 0x10 }
+  - { offsetInCU: 0x11DA, offset: 0x7C666, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvsTo', symObjAddr: 0x395C, symBinAddr: 0xB7DC, symSize: 0x34 }
+  - { offsetInCU: 0x1248, offset: 0x7C6D4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13readyListenerAA0cE0_pSgvgTo', symObjAddr: 0x3A10, symBinAddr: 0xB890, symSize: 0x20 }
+  - { offsetInCU: 0x12A2, offset: 0x7C72E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13readyListenerAA0cE0_pSgvsTo', symObjAddr: 0x3A30, symBinAddr: 0xB8B0, symSize: 0x34 }
+  - { offsetInCU: 0x1302, offset: 0x7C78E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11setListeneryyAA0cE0_pSgFTo', symObjAddr: 0x3A94, symBinAddr: 0xB914, symSize: 0x34 }
+  - { offsetInCU: 0x1446, offset: 0x7C8D2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC14layoutSubviewsyyFTo', symObjAddr: 0x3DE0, symBinAddr: 0xBC60, symSize: 0x28 }
+  - { offsetInCU: 0x1479, offset: 0x7C905, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCfDTo', symObjAddr: 0x410C, symBinAddr: 0xBF8C, symSize: 0x24 }
+  - { offsetInCU: 0x14B4, offset: 0x7C940, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC21getBoundingClientRectyySo6UIViewC_SvtFZTo', symObjAddr: 0x41F8, symBinAddr: 0xC078, symSize: 0x34 }
+  - { offsetInCU: 0x14E7, offset: 0x7C973, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC14shared_context33_508084857CA7D194CA72FEB80DD78002LLs5Int64VvgZTf4d_n', symObjAddr: 0x4B8C, symBinAddr: 0xCA0C, symSize: 0x298 }
+  - { offsetInCU: 0x1664, offset: 0x7CAF0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC21getBoundingClientRectyySo6UIViewC_SvtFZTf4nnd_n', symObjAddr: 0x4EE8, symBinAddr: 0xCD68, symSize: 0xA0 }
+  - { offsetInCU: 0x18E0, offset: 0x7CD6C, size: 0x8, addend: 0x0, symName: '_$sIeg_IeyB_TR', symObjAddr: 0x1E98, symBinAddr: 0x9D18, symSize: 0x2C }
+  - { offsetInCU: 0x18F8, offset: 0x7CD84, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_So8NSStringCABIeyByy_TR', symObjAddr: 0x2148, symBinAddr: 0x9FC8, symSize: 0x78 }
+  - { offsetInCU: 0x1910, offset: 0x7CD9C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvpACTK', symObjAddr: 0x22B0, symBinAddr: 0xA130, symSize: 0x94 }
+  - { offsetInCU: 0x1948, offset: 0x7CDD4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvpACTk', symObjAddr: 0x2344, symBinAddr: 0xA1C4, symSize: 0xB8 }
+  - { offsetInCU: 0x198A, offset: 0x7CE16, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCytIegnnr_SSABIeggg_TR', symObjAddr: 0x23FC, symBinAddr: 0xA27C, symSize: 0x6C }
+  - { offsetInCU: 0x1A3A, offset: 0x7CEC6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCfETo', symObjAddr: 0x4130, symBinAddr: 0xBFB0, symSize: 0xC4 }
+  - { offsetInCU: 0x1A6A, offset: 0x7CEF6, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_SgWOy', symObjAddr: 0x422C, symBinAddr: 0xC0AC, symSize: 0x10 }
+  - { offsetInCU: 0x1A7E, offset: 0x7CF0A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCMa', symObjAddr: 0x423C, symBinAddr: 0xC0BC, symSize: 0x20 }
+  - { offsetInCU: 0x1A92, offset: 0x7CF1E, size: 0x8, addend: 0x0, symName: '_$ss29getContiguousArrayStorageType3fors01_bcD0CyxGmxm_tlFSo18NSLayoutConstraintC_Tgm5', symObjAddr: 0x425C, symBinAddr: 0xC0DC, symSize: 0x64 }
+  - { offsetInCU: 0x1C99, offset: 0x7D125, size: 0x8, addend: 0x0, symName: ___swift_instantiateConcreteTypeFromMangledName, symObjAddr: 0x4E24, symBinAddr: 0xCCA4, symSize: 0x40 }
+  - { offsetInCU: 0x1CAD, offset: 0x7D139, size: 0x8, addend: 0x0, symName: '_$sypSgWOh', symObjAddr: 0x4E64, symBinAddr: 0xCCE4, symSize: 0x40 }
+  - { offsetInCU: 0x1CC1, offset: 0x7D14D, size: 0x8, addend: 0x0, symName: ___swift_project_boxed_opaque_existential_0, symObjAddr: 0x4EA4, symBinAddr: 0xCD24, symSize: 0x24 }
+  - { offsetInCU: 0x1CD5, offset: 0x7D161, size: 0x8, addend: 0x0, symName: ___swift_destroy_boxed_opaque_existential_0, symObjAddr: 0x4EC8, symBinAddr: 0xCD48, symSize: 0x20 }
+  - { offsetInCU: 0x1CF4, offset: 0x7D180, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSo19UIGestureRecognizerCIeyByy_SSADIeggg_TRTA', symObjAddr: 0x53B4, symBinAddr: 0xD234, symSize: 0x48 }
+  - { offsetInCU: 0x1D1D, offset: 0x7D1A9, size: 0x8, addend: 0x0, symName: _block_copy_helper, symObjAddr: 0x53FC, symBinAddr: 0xD27C, symSize: 0x10 }
+  - { offsetInCU: 0x1D31, offset: 0x7D1BD, size: 0x8, addend: 0x0, symName: _block_destroy_helper, symObjAddr: 0x540C, symBinAddr: 0xD28C, symSize: 0x8 }
+  - { offsetInCU: 0x1D45, offset: 0x7D1D1, size: 0x8, addend: 0x0, symName: '_$sIeg_SgWOe', symObjAddr: 0x5414, symBinAddr: 0xD294, symSize: 0x10 }
+  - { offsetInCU: 0x1D64, offset: 0x7D1F0, size: 0x8, addend: 0x0, symName: '_$sIeyB_Ieg_TRTA', symObjAddr: 0x5424, symBinAddr: 0xD2A4, symSize: 0xC }
+  - { offsetInCU: 0x1D8D, offset: 0x7D219, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCytIegnnr_SSABIeggg_TRTA', symObjAddr: 0x5454, symBinAddr: 0xD2D4, symSize: 0x8 }
+  - { offsetInCU: 0x1DAC, offset: 0x7D238, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_SSABytIegnnr_TRTA', symObjAddr: 0x545C, symBinAddr: 0xD2DC, symSize: 0x30 }
+  - { offsetInCU: 0x1DD5, offset: 0x7D261, size: 0x8, addend: 0x0, symName: '_$sypWOb', symObjAddr: 0x548C, symBinAddr: 0xD30C, symSize: 0x10 }
+  - { offsetInCU: 0x1DE9, offset: 0x7D275, size: 0x8, addend: 0x0, symName: '_$sypWOc', symObjAddr: 0x54D4, symBinAddr: 0xD354, symSize: 0x3C }
+  - { offsetInCU: 0x206E, offset: 0x7D4FA, size: 0x8, addend: 0x0, symName: '_$sSD17dictionaryLiteralSDyxq_Gx_q_td_tcfCSS_ypTgm5Tf4g_n', symObjAddr: 0x4A7C, symBinAddr: 0xC8FC, symSize: 0x110 }
+  - { offsetInCU: 0x251C, offset: 0x7D9A8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvg', symObjAddr: 0x2E0, symBinAddr: 0x8160, symSize: 0x44 }
+  - { offsetInCU: 0x254F, offset: 0x7D9DB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvs', symObjAddr: 0x354, symBinAddr: 0x81D4, symSize: 0xEC }
+  - { offsetInCU: 0x259B, offset: 0x7DA27, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvM', symObjAddr: 0x440, symBinAddr: 0x82C0, symSize: 0x58 }
+  - { offsetInCU: 0x25C0, offset: 0x7DA4C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvM.resume.0', symObjAddr: 0x498, symBinAddr: 0x8318, symSize: 0xE0 }
+  - { offsetInCU: 0x2601, offset: 0x7DA8D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8nativeGLs5Int64Vvg', symObjAddr: 0x5BC, symBinAddr: 0x843C, symSize: 0x44 }
+  - { offsetInCU: 0x2659, offset: 0x7DAE5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13nativeContexts5Int64Vvg', symObjAddr: 0x68C, symBinAddr: 0x850C, symSize: 0x44 }
+  - { offsetInCU: 0x27C7, offset: 0x7DC53, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18drawingBufferWidthSivg', symObjAddr: 0x834, symBinAddr: 0x86B4, symSize: 0xD0 }
+  - { offsetInCU: 0x28EC, offset: 0x7DD78, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19drawingBufferHeightSivg', symObjAddr: 0x938, symBinAddr: 0x87B8, symSize: 0xD0 }
+  - { offsetInCU: 0x2A32, offset: 0x7DEBE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5widthSfvg', symObjAddr: 0xA28, symBinAddr: 0x88A8, symSize: 0x24 }
+  - { offsetInCU: 0x2A7A, offset: 0x7DF06, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6heightSfvg', symObjAddr: 0xA6C, symBinAddr: 0x88EC, symSize: 0x24 }
+  - { offsetInCU: 0x2AAE, offset: 0x7DF3A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11initContextyySS_S4bs5Int32VS5btF', symObjAddr: 0xA90, symBinAddr: 0x8910, symSize: 0x24 }
+  - { offsetInCU: 0x2C3C, offset: 0x7E0C8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17initWebGPUContextyys5Int64VF', symObjAddr: 0xB78, symBinAddr: 0x89F8, symSize: 0x198 }
+  - { offsetInCU: 0x302F, offset: 0x7E4BB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC015initContextWithE10AttributesyySS_S4bs5Int32VS5btF', symObjAddr: 0xD40, symBinAddr: 0x8BC0, symSize: 0x870 }
+  - { offsetInCU: 0x3832, offset: 0x7ECBE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15create2DContextys5Int64VSb_S3bs5Int32VS5bAHtF', symObjAddr: 0x1674, symBinAddr: 0x94F4, symSize: 0x258 }
+  - { offsetInCU: 0x3C64, offset: 0x7F0F0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11forceLayoutyy12CoreGraphics7CGFloatV_AGtF', symObjAddr: 0x197C, symBinAddr: 0x97FC, symSize: 0xC0 }
+  - { offsetInCU: 0x3CF5, offset: 0x7F181, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8snapshotySo7UIImageCSgSbF', symObjAddr: 0x1AF4, symBinAddr: 0x9974, symSize: 0xE4 }
+  - { offsetInCU: 0x3E50, offset: 0x7F2DC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6renderSbyF', symObjAddr: 0x1C58, symBinAddr: 0x9AD8, symSize: 0x48 }
+  - { offsetInCU: 0x3ED6, offset: 0x7F362, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13context2DTestyys5Int64VF', symObjAddr: 0x1CE8, symBinAddr: 0x9B68, symSize: 0x4C }
+  - { offsetInCU: 0x3FF7, offset: 0x7F483, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC22context2DTestToDataURLySSs5Int64VF', symObjAddr: 0x1D98, symBinAddr: 0x9C18, symSize: 0x58 }
+  - { offsetInCU: 0x40ED, offset: 0x7F579, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvg', symObjAddr: 0x20F0, symBinAddr: 0x9F70, symSize: 0x58 }
+  - { offsetInCU: 0x4139, offset: 0x7F5C5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvs', symObjAddr: 0x2254, symBinAddr: 0xA0D4, symSize: 0x5C }
+  - { offsetInCU: 0x4162, offset: 0x7F5EE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvM', symObjAddr: 0x2468, symBinAddr: 0xA2E8, symSize: 0x44 }
+  - { offsetInCU: 0x4188, offset: 0x7F614, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvM.resume.0', symObjAddr: 0x24AC, symBinAddr: 0xA32C, symSize: 0x4 }
+  - { offsetInCU: 0x424A, offset: 0x7F6D6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5coderACSgSo7NSCoderC_tcfc', symObjAddr: 0x24B0, symBinAddr: 0xA330, symSize: 0x9FC }
+  - { offsetInCU: 0x446D, offset: 0x7F8F9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5frameACSo6CGRectV_tcfC', symObjAddr: 0x2ED4, symBinAddr: 0xAD54, symSize: 0x50 }
+  - { offsetInCU: 0x4496, offset: 0x7F922, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5frameACSo6CGRectV_tcfc', symObjAddr: 0x2F24, symBinAddr: 0xADA4, symSize: 0xA08 }
+  - { offsetInCU: 0x46DA, offset: 0x7FB66, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvW', symObjAddr: 0x3990, symBinAddr: 0xB810, symSize: 0x80 }
+  - { offsetInCU: 0x47D0, offset: 0x7FC5C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11setListeneryyAA0cE0_pSgF', symObjAddr: 0x3A64, symBinAddr: 0xB8E4, symSize: 0x30 }
+  - { offsetInCU: 0x486E, offset: 0x7FCFA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6resize33_508084857CA7D194CA72FEB80DD78002LLyyF', symObjAddr: 0x3AC8, symBinAddr: 0xB948, symSize: 0x144 }
+  - { offsetInCU: 0x4A6F, offset: 0x7FEFB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC14layoutSubviewsyyF', symObjAddr: 0x3C0C, symBinAddr: 0xBA8C, symSize: 0x1D4 }
+  - { offsetInCU: 0x4CEC, offset: 0x80178, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCfD', symObjAddr: 0x3E08, symBinAddr: 0xBC88, symSize: 0x304 }
+  - { offsetInCU: 0x4D7C, offset: 0x80208, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC21getBoundingClientRectyySo6UIViewC_SvtFZ', symObjAddr: 0x41F4, symBinAddr: 0xC074, symSize: 0x4 }
+  - { offsetInCU: 0x4DA4, offset: 0x80230, size: 0x8, addend: 0x0, symName: '_$ss22__RawDictionaryStorageC4findys10_HashTableV6BucketV6bucket_Sb5foundtxSHRzlFSS_Tg5', symObjAddr: 0x42C0, symBinAddr: 0xC140, symSize: 0x64 }
+  - { offsetInCU: 0x4DFE, offset: 0x8028A, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV7_insert2at3key5valueys10_HashTableV6BucketV_xnq_ntFSS_ypTg5', symObjAddr: 0x4324, symBinAddr: 0xC1A4, symSize: 0x6C }
+  - { offsetInCU: 0x4E7E, offset: 0x8030A, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV12mutatingFind_8isUniques10_HashTableV6BucketV6bucket_Sb5foundtx_SbtFSS_ypTg5', symObjAddr: 0x4390, symBinAddr: 0xC210, symSize: 0xD8 }
+  - { offsetInCU: 0x4EBB, offset: 0x80347, size: 0x8, addend: 0x0, symName: '_$ss22__RawDictionaryStorageC4find_9hashValues10_HashTableV6BucketV6bucket_Sb5foundtx_SitSHRzlFSS_Tg5', symObjAddr: 0x4468, symBinAddr: 0xC2E8, symSize: 0xE0 }
+  - { offsetInCU: 0x4F36, offset: 0x803C2, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV4copyyyFSS_ypTg5', symObjAddr: 0x4548, symBinAddr: 0xC3C8, symSize: 0x1F4 }
+  - { offsetInCU: 0x4FF2, offset: 0x8047E, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV20_copyOrMoveAndResize8capacity12moveElementsySi_SbtFSS_ypTg5', symObjAddr: 0x473C, symBinAddr: 0xC5BC, symSize: 0x340 }
+  - { offsetInCU: 0x27, offset: 0x806E6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative7GLUtilsCfD', symObjAddr: 0x0, symBinAddr: 0xD3F4, symSize: 0x10 }
+  - { offsetInCU: 0x62, offset: 0x80721, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative7GLUtilsCMa', symObjAddr: 0x10, symBinAddr: 0xD404, symSize: 0x20 }
+  - { offsetInCU: 0x1AF, offset: 0x8086E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative7GLUtilsCfD', symObjAddr: 0x0, symBinAddr: 0xD3F4, symSize: 0x10 }
+  - { offsetInCU: 0x65, offset: 0x808FD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8mPrograms6UInt32VvgTo', symObjAddr: 0x0, symBinAddr: 0xD424, symSize: 0x10 }
+  - { offsetInCU: 0x85, offset: 0x8091D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8mPrograms6UInt32VvgTo', symObjAddr: 0x0, symBinAddr: 0xD424, symSize: 0x10 }
+  - { offsetInCU: 0xBB, offset: 0x80953, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8mPrograms6UInt32VvsTo', symObjAddr: 0x10, symBinAddr: 0xD434, symSize: 0x10 }
+  - { offsetInCU: 0xDB, offset: 0x80973, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8mPrograms6UInt32VvsTo', symObjAddr: 0x10, symBinAddr: 0xD434, symSize: 0x10 }
+  - { offsetInCU: 0x114, offset: 0x809AC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3rbos6UInt32VvgTo', symObjAddr: 0x20, symBinAddr: 0xD444, symSize: 0x44 }
+  - { offsetInCU: 0x16C, offset: 0x80A04, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3rbos6UInt32VvsTo', symObjAddr: 0x64, symBinAddr: 0xD488, symSize: 0x48 }
+  - { offsetInCU: 0x1C7, offset: 0x80A5F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3fbos6UInt32VvgTo', symObjAddr: 0xAC, symBinAddr: 0xD4D0, symSize: 0x44 }
+  - { offsetInCU: 0x21F, offset: 0x80AB7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3fbos6UInt32VvsTo', symObjAddr: 0xF0, symBinAddr: 0xD514, symSize: 0x48 }
+  - { offsetInCU: 0x27A, offset: 0x80B12, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC5widthSivgTo', symObjAddr: 0x138, symBinAddr: 0xD55C, symSize: 0x10 }
+  - { offsetInCU: 0x29A, offset: 0x80B32, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC5widthSivgTo', symObjAddr: 0x138, symBinAddr: 0xD55C, symSize: 0x10 }
+  - { offsetInCU: 0x2D0, offset: 0x80B68, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC5widthSivsTo', symObjAddr: 0x148, symBinAddr: 0xD56C, symSize: 0x10 }
+  - { offsetInCU: 0x2F0, offset: 0x80B88, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC5widthSivsTo', symObjAddr: 0x148, symBinAddr: 0xD56C, symSize: 0x10 }
+  - { offsetInCU: 0x329, offset: 0x80BC1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC6heightSivgTo', symObjAddr: 0x158, symBinAddr: 0xD57C, symSize: 0x10 }
+  - { offsetInCU: 0x349, offset: 0x80BE1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC6heightSivgTo', symObjAddr: 0x158, symBinAddr: 0xD57C, symSize: 0x10 }
+  - { offsetInCU: 0x37F, offset: 0x80C17, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC6heightSivsTo', symObjAddr: 0x168, symBinAddr: 0xD58C, symSize: 0x10 }
+  - { offsetInCU: 0x39F, offset: 0x80C37, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC6heightSivsTo', symObjAddr: 0x168, symBinAddr: 0xD58C, symSize: 0x10 }
+  - { offsetInCU: 0x3D8, offset: 0x80C70, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC2abs6UInt32VvgTo', symObjAddr: 0x178, symBinAddr: 0xD59C, symSize: 0x44 }
+  - { offsetInCU: 0x430, offset: 0x80CC8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC2abs6UInt32VvsTo', symObjAddr: 0x1BC, symBinAddr: 0xD5E0, symSize: 0x48 }
+  - { offsetInCU: 0x48B, offset: 0x80D23, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3poss5Int32VvgTo', symObjAddr: 0x204, symBinAddr: 0xD628, symSize: 0x10 }
+  - { offsetInCU: 0x4AB, offset: 0x80D43, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3poss5Int32VvgTo', symObjAddr: 0x204, symBinAddr: 0xD628, symSize: 0x10 }
+  - { offsetInCU: 0x4E1, offset: 0x80D79, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3poss5Int32VvsTo', symObjAddr: 0x214, symBinAddr: 0xD638, symSize: 0x10 }
+  - { offsetInCU: 0x501, offset: 0x80D99, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3poss5Int32VvsTo', symObjAddr: 0x214, symBinAddr: 0xD638, symSize: 0x10 }
+  - { offsetInCU: 0x53A, offset: 0x80DD2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10samplerPoss5Int32VvgTo', symObjAddr: 0x224, symBinAddr: 0xD648, symSize: 0x10 }
+  - { offsetInCU: 0x55A, offset: 0x80DF2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10samplerPoss5Int32VvgTo', symObjAddr: 0x224, symBinAddr: 0xD648, symSize: 0x10 }
+  - { offsetInCU: 0x590, offset: 0x80E28, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10samplerPoss5Int32VvsTo', symObjAddr: 0x234, symBinAddr: 0xD658, symSize: 0x10 }
+  - { offsetInCU: 0x5B0, offset: 0x80E48, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10samplerPoss5Int32VvsTo', symObjAddr: 0x234, symBinAddr: 0xD658, symSize: 0x10 }
+  - { offsetInCU: 0x5E9, offset: 0x80E81, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9vextexBufSaySfGvgTo', symObjAddr: 0x244, symBinAddr: 0xD668, symSize: 0x48 }
+  - { offsetInCU: 0x63F, offset: 0x80ED7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9vextexBufSaySfGvsTo', symObjAddr: 0x28C, symBinAddr: 0xD6B0, symSize: 0x40 }
+  - { offsetInCU: 0x682, offset: 0x80F1A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13SIZE_OF_FLOATSivgZTo', symObjAddr: 0x2CC, symBinAddr: 0xD6F0, symSize: 0x8 }
+  - { offsetInCU: 0x69E, offset: 0x80F36, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13VERTEX_SHADERSSvgZTo', symObjAddr: 0x2D4, symBinAddr: 0xD6F8, symSize: 0x2C }
+  - { offsetInCU: 0x6D0, offset: 0x80F68, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7surfaceSo9IOSurfaceCSgvgTo', symObjAddr: 0x300, symBinAddr: 0xD724, symSize: 0x10 }
+  - { offsetInCU: 0x6F0, offset: 0x80F88, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7surfaceSo9IOSurfaceCSgvgTo', symObjAddr: 0x300, symBinAddr: 0xD724, symSize: 0x10 }
+  - { offsetInCU: 0x728, offset: 0x80FC0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7surfaceSo9IOSurfaceCSgvsTo', symObjAddr: 0x310, symBinAddr: 0xD734, symSize: 0x34 }
+  - { offsetInCU: 0x781, offset: 0x81019, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8pixelBufs9UnmanagedVySo11CVBufferRefaGSgvgTo', symObjAddr: 0x418, symBinAddr: 0xD83C, symSize: 0x10 }
+  - { offsetInCU: 0x7A1, offset: 0x81039, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8pixelBufs9UnmanagedVySo11CVBufferRefaGSgvgTo', symObjAddr: 0x418, symBinAddr: 0xD83C, symSize: 0x10 }
+  - { offsetInCU: 0x7D7, offset: 0x8106F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8pixelBufs9UnmanagedVySo11CVBufferRefaGSgvsTo', symObjAddr: 0x428, symBinAddr: 0xD84C, symSize: 0x10 }
+  - { offsetInCU: 0x7F7, offset: 0x8108F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8pixelBufs9UnmanagedVySo11CVBufferRefaGSgvsTo', symObjAddr: 0x428, symBinAddr: 0xD84C, symSize: 0x10 }
+  - { offsetInCU: 0x846, offset: 0x810DE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCACycfcTo', symObjAddr: 0x5A4, symBinAddr: 0xD988, symSize: 0x20 }
+  - { offsetInCU: 0x878, offset: 0x81110, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7destroyyyFTo', symObjAddr: 0x708, symBinAddr: 0xDAEC, symSize: 0x28 }
+  - { offsetInCU: 0x8D0, offset: 0x81168, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10texImage2Dyys5Int32V_A4fA9NSCCanvasCAHSbtFTo', symObjAddr: 0x744, symBinAddr: 0xDB28, symSize: 0x88 }
+  - { offsetInCU: 0x934, offset: 0x811CC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9drawFrame6buffer5width6height14internalFormat6format10flipYWebGLySo11CVBufferRefa_S2is5Int32VANSbtFTo', symObjAddr: 0x7CC, symBinAddr: 0xDBB0, symSize: 0x7C }
+  - { offsetInCU: 0x9D6, offset: 0x8126E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13createSurfaceyyFTo', symObjAddr: 0xBF4, symBinAddr: 0xDFD8, symSize: 0x28 }
+  - { offsetInCU: 0xAC0, offset: 0x81358, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCMa', symObjAddr: 0x584, symBinAddr: 0xD968, symSize: 0x20 }
+  - { offsetInCU: 0xB34, offset: 0x813CC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCfETo', symObjAddr: 0xC4C, symBinAddr: 0xE030, symSize: 0x58 }
+  - { offsetInCU: 0x123B, offset: 0x81AD3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCACycfC', symObjAddr: 0x438, symBinAddr: 0xD85C, symSize: 0x20 }
+  - { offsetInCU: 0x1255, offset: 0x81AED, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCACycfc', symObjAddr: 0x458, symBinAddr: 0xD87C, symSize: 0xEC }
+  - { offsetInCU: 0x128D, offset: 0x81B25, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7destroyyyF', symObjAddr: 0x5C4, symBinAddr: 0xD9A8, symSize: 0x144 }
+  - { offsetInCU: 0x1448, offset: 0x81CE0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10texImage2Dyys5Int32V_A4fA9NSCCanvasCAHSbtF', symObjAddr: 0x730, symBinAddr: 0xDB14, symSize: 0x14 }
+  - { offsetInCU: 0x14F9, offset: 0x81D91, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13createSurfaceyyF', symObjAddr: 0x848, symBinAddr: 0xDC2C, symSize: 0x3AC }
+  - { offsetInCU: 0x1869, offset: 0x82101, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCfD', symObjAddr: 0xC1C, symBinAddr: 0xE000, symSize: 0x30 }
+  - { offsetInCU: 0x1954, offset: 0x821EC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10texImage2Dyys5Int32V_A4fA9NSCCanvasCAHSbtFTf4ddnndnndn_n', symObjAddr: 0xCA4, symBinAddr: 0xE088, symSize: 0x65C }
+  - { offsetInCU: 0x2152, offset: 0x829EA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9drawFrame6buffer5width6height14internalFormat6format10flipYWebGLySo11CVBufferRefa_S2is5Int32VANSbtFTf4nnnnndn_n', symObjAddr: 0x1344, symBinAddr: 0xE728, symSize: 0x6C8 }
+  - { offsetInCU: 0x10C, offset: 0x833AA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC6target6actionAEypSg_10ObjectiveC8SelectorVSgtcfcTo', symObjAddr: 0xED4, symBinAddr: 0xFC9C, symSize: 0x68 }
+  - { offsetInCU: 0x19C, offset: 0x8343A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerCfETo', symObjAddr: 0xF48, symBinAddr: 0xFD10, symSize: 0x10 }
+  - { offsetInCU: 0x1CB, offset: 0x83469, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC6handleyySo19UIGestureRecognizerCFTo', symObjAddr: 0xF58, symBinAddr: 0xFD20, symSize: 0x4 }
+  - { offsetInCU: 0x368, offset: 0x83606, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerCACycfcTo', symObjAddr: 0x16DC, symBinAddr: 0x104A4, symSize: 0x2C }
+  - { offsetInCU: 0x5D4, offset: 0x83872, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerCfETo', symObjAddr: 0x1744, symBinAddr: 0x1050C, symSize: 0x68 }
+  - { offsetInCU: 0x603, offset: 0x838A1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerCMa', symObjAddr: 0x17AC, symBinAddr: 0x10574, symSize: 0x20 }
+  - { offsetInCU: 0x617, offset: 0x838B5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerCMa', symObjAddr: 0x17CC, symBinAddr: 0x10594, symSize: 0x20 }
+  - { offsetInCU: 0x62B, offset: 0x838C9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwCP', symObjAddr: 0x17EC, symBinAddr: 0x105B4, symSize: 0x30 }
+  - { offsetInCU: 0x63F, offset: 0x838DD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwxx', symObjAddr: 0x181C, symBinAddr: 0x105E4, symSize: 0x8 }
+  - { offsetInCU: 0x653, offset: 0x838F1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwcp', symObjAddr: 0x1824, symBinAddr: 0x105EC, symSize: 0x3C }
+  - { offsetInCU: 0x667, offset: 0x83905, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwca', symObjAddr: 0x1860, symBinAddr: 0x10628, symSize: 0x50 }
+  - { offsetInCU: 0x67B, offset: 0x83919, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwta', symObjAddr: 0x18BC, symBinAddr: 0x10678, symSize: 0x40 }
+  - { offsetInCU: 0x68F, offset: 0x8392D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwet', symObjAddr: 0x18FC, symBinAddr: 0x106B8, symSize: 0x48 }
+  - { offsetInCU: 0x6A3, offset: 0x83941, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwst', symObjAddr: 0x1944, symBinAddr: 0x10700, symSize: 0x40 }
+  - { offsetInCU: 0x6B7, offset: 0x83955, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVMa', symObjAddr: 0x1984, symBinAddr: 0x10740, symSize: 0x10 }
+  - { offsetInCU: 0x6CB, offset: 0x83969, size: 0x8, addend: 0x0, symName: '_$sypSgWOc', symObjAddr: 0x1994, symBinAddr: 0x10750, symSize: 0x48 }
+  - { offsetInCU: 0x6DF, offset: 0x8397D, size: 0x8, addend: 0x0, symName: '_$sSo7UITouchCSo8NSObjectCSH10ObjectiveCWl', symObjAddr: 0x1AA0, symBinAddr: 0x10798, symSize: 0x58 }
+  - { offsetInCU: 0x6F3, offset: 0x83991, size: 0x8, addend: 0x0, symName: '_$sSh8IteratorV8_VariantOyx__GSHRzlWOe', symObjAddr: 0x1AF8, symBinAddr: 0x107F0, symSize: 0x8 }
+  - { offsetInCU: 0x761, offset: 0x839FF, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_SgWOe', symObjAddr: 0x1DE4, symBinAddr: 0x10ADC, symSize: 0x10 }
+  - { offsetInCU: 0xCBB, offset: 0x83F59, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC12touchesBegan_4withyShySo7UITouchCG_So7UIEventCtF', symObjAddr: 0x0, symBinAddr: 0xEDF0, symSize: 0x540 }
+  - { offsetInCU: 0xF57, offset: 0x841F5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC12touchesMoved_4withyShySo7UITouchCG_So7UIEventCtF', symObjAddr: 0x54C, symBinAddr: 0xF33C, symSize: 0xE0 }
+  - { offsetInCU: 0xFD6, offset: 0x84274, size: 0x8, addend: 0x0, symName: '_$sSa6remove2atxSi_tF12CanvasNative15NSCTouchHandlerC7PointerV_Tg5', symObjAddr: 0x6F0, symBinAddr: 0xF4CC, symSize: 0x9C }
+  - { offsetInCU: 0x1069, offset: 0x84307, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC6target6actionAEypSg_10ObjectiveC8SelectorVSgtcfc', symObjAddr: 0xDCC, symBinAddr: 0xFB94, symSize: 0x108 }
+  - { offsetInCU: 0x11B3, offset: 0x84451, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC6onMove33_044DDF836BDB3B89B481C6F58BB6EF6BLLyySo19UIGestureRecognizerC_ShySo7UITouchCGSgtF', symObjAddr: 0x12D0, symBinAddr: 0x10098, symSize: 0x40C }
+  - { offsetInCU: 0x18C9, offset: 0x84B67, size: 0x8, addend: 0x0, symName: '_$ss12_ArrayBufferV20_consumeAndCreateNewAByxGyF12CanvasNative15NSCTouchHandlerC7PointerV_Tg5', symObjAddr: 0x1B00, symBinAddr: 0x107F8, symSize: 0x14 }
+  - { offsetInCU: 0x1968, offset: 0x84C06, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC6canvasAcA9NSCCanvasC_tcfcTf4gn_n', symObjAddr: 0x1B14, symBinAddr: 0x1080C, symSize: 0x1DC }
+  - { offsetInCU: 0x27, offset: 0x84DE3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC14FAILED_TO_LOADSSvgZTo', symObjAddr: 0x0, symBinAddr: 0x10AEC, symSize: 0x2C }
+  - { offsetInCU: 0x4B, offset: 0x84E07, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queueSo012OS_dispatch_E0CvpZ', symObjAddr: 0x2D8, symBinAddr: 0x1150078, symSize: 0x0 }
+  - { offsetInCU: 0x65, offset: 0x84E21, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC14FAILED_TO_LOADSSvgZTo', symObjAddr: 0x0, symBinAddr: 0x10AEC, symSize: 0x2C }
+  - { offsetInCU: 0x98, offset: 0x84E54, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queueSo012OS_dispatch_E0CvgZTo', symObjAddr: 0x178, symBinAddr: 0x10C64, symSize: 0x40 }
+  - { offsetInCU: 0x104, offset: 0x84EC0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCACycfcTo', symObjAddr: 0x228, symBinAddr: 0x10D14, symSize: 0x3C }
+  - { offsetInCU: 0x156, offset: 0x84F12, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queue_WZ', symObjAddr: 0x2C, symBinAddr: 0x10B18, symSize: 0x10C }
+  - { offsetInCU: 0x181, offset: 0x84F3D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCMa', symObjAddr: 0x208, symBinAddr: 0x10CF4, symSize: 0x20 }
+  - { offsetInCU: 0x195, offset: 0x84F51, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCfETo', symObjAddr: 0x294, symBinAddr: 0x10D80, symSize: 0x4 }
+  - { offsetInCU: 0x1C0, offset: 0x84F7C, size: 0x8, addend: 0x0, symName: '_$sSo17OS_dispatch_queueCMa', symObjAddr: 0x298, symBinAddr: 0x10D84, symSize: 0x3C }
+  - { offsetInCU: 0x348, offset: 0x85104, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queueSo012OS_dispatch_E0CvgZ', symObjAddr: 0x138, symBinAddr: 0x10C24, symSize: 0x40 }
+  - { offsetInCU: 0x388, offset: 0x85144, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCACycfC', symObjAddr: 0x1B8, symBinAddr: 0x10CA4, symSize: 0x20 }
+  - { offsetInCU: 0x39C, offset: 0x85158, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCACycfc', symObjAddr: 0x1D8, symBinAddr: 0x10CC4, symSize: 0x30 }
+  - { offsetInCU: 0x3D8, offset: 0x85194, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCfD', symObjAddr: 0x264, symBinAddr: 0x10D50, symSize: 0x30 }
+  - { offsetInCU: 0x2B, offset: 0x851E2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC18createTextureCacheSo017CVOpenGLESTextureF3RefaSgyFZ', symObjAddr: 0x0, symBinAddr: 0x10DC0, symSize: 0xA4 }
+  - { offsetInCU: 0x66, offset: 0x8521D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC18createTextureCacheSo017CVOpenGLESTextureF3RefaSgyFZTo', symObjAddr: 0xA4, symBinAddr: 0x10E64, symSize: 0xA4 }
+  - { offsetInCU: 0xF9, offset: 0x852B0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11createImageySo11CVBufferRefaSgSo022CVOpenGLESTextureCacheG0a_AFSo012CFDictionaryG0aSgs6UInt32Vs5Int32VA2p2NSitFZTo', symObjAddr: 0x1D8, symBinAddr: 0x10F98, symSize: 0x110 }
+  - { offsetInCU: 0x1A2, offset: 0x85359, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11setupRenderAA9NSCRenderCyFZTo', symObjAddr: 0x30C, symBinAddr: 0x110CC, symSize: 0x28 }
+  - { offsetInCU: 0x222, offset: 0x853D9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC9drawFrameyySo8AVPlayerC_So0F15ItemVideoOutputCSo6CGSizeVAA9NSCRenderCs5Int32VANSbtFZTo', symObjAddr: 0x338, symBinAddr: 0x110F8, symSize: 0xA0 }
+  - { offsetInCU: 0x29B, offset: 0x85452, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11writeToFileyySo6NSDataC_SStKFZTo', symObjAddr: 0x4D0, symBinAddr: 0x11290, symSize: 0x15C }
+  - { offsetInCU: 0x330, offset: 0x854E7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCACycfcTo', symObjAddr: 0x67C, symBinAddr: 0x1143C, symSize: 0x3C }
+  - { offsetInCU: 0x381, offset: 0x85538, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC9drawFrameyySo8AVPlayerC_So0F15ItemVideoOutputCSo6CGSizeVAA9NSCRenderCs5Int32VANSbtFZTf4nnnnnndd_n', symObjAddr: 0x6E8, symBinAddr: 0x114A8, symSize: 0x160 }
+  - { offsetInCU: 0x4DF, offset: 0x85696, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC7getFile33_F00B23A4165DD6ABFCD23C8811C7DF43LLyS2SKFZTf4nd_g', symObjAddr: 0x848, symBinAddr: 0x11608, symSize: 0x2E4 }
+  - { offsetInCU: 0x5AE, offset: 0x85765, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCMa', symObjAddr: 0xB2C, symBinAddr: 0x118EC, symSize: 0x20 }
+  - { offsetInCU: 0x5C2, offset: 0x85779, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOAEs5ErrorAAWl', symObjAddr: 0xB4C, symBinAddr: 0x1190C, symSize: 0x44 }
+  - { offsetInCU: 0x5D6, offset: 0x8578D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwCP', symObjAddr: 0xB90, symBinAddr: 0x11950, symSize: 0x2C }
+  - { offsetInCU: 0x5EA, offset: 0x857A1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwxx', symObjAddr: 0xBBC, symBinAddr: 0x1197C, symSize: 0x8 }
+  - { offsetInCU: 0x5FE, offset: 0x857B5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwca', symObjAddr: 0xBC4, symBinAddr: 0x11984, symSize: 0x40 }
+  - { offsetInCU: 0x612, offset: 0x857C9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwta', symObjAddr: 0xC10, symBinAddr: 0x119C4, symSize: 0x30 }
+  - { offsetInCU: 0x626, offset: 0x857DD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwet', symObjAddr: 0xC40, symBinAddr: 0x119F4, symSize: 0x48 }
+  - { offsetInCU: 0x63A, offset: 0x857F1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwst', symObjAddr: 0xC88, symBinAddr: 0x11A3C, symSize: 0x3C }
+  - { offsetInCU: 0x64E, offset: 0x85805, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwug', symObjAddr: 0xCC4, symBinAddr: 0x11A78, symSize: 0x8 }
+  - { offsetInCU: 0x662, offset: 0x85819, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwup', symObjAddr: 0xCCC, symBinAddr: 0x11A80, symSize: 0x4 }
+  - { offsetInCU: 0x676, offset: 0x8582D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwui', symObjAddr: 0xCD0, symBinAddr: 0x11A84, symSize: 0x4 }
+  - { offsetInCU: 0x68A, offset: 0x85841, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOMa', symObjAddr: 0xCD4, symBinAddr: 0x11A88, symSize: 0x10 }
+  - { offsetInCU: 0x712, offset: 0x858C9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP7_domainSSvgTW', symObjAddr: 0x3D8, symBinAddr: 0x11198, symSize: 0x4 }
+  - { offsetInCU: 0x72E, offset: 0x858E5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP5_codeSivgTW', symObjAddr: 0x3DC, symBinAddr: 0x1119C, symSize: 0x4 }
+  - { offsetInCU: 0x74A, offset: 0x85901, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP9_userInfoyXlSgvgTW', symObjAddr: 0x3E0, symBinAddr: 0x111A0, symSize: 0x4 }
+  - { offsetInCU: 0x766, offset: 0x8591D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP19_getEmbeddedNSErroryXlSgyFTW', symObjAddr: 0x3E4, symBinAddr: 0x111A4, symSize: 0x4 }
+  - { offsetInCU: 0xA14, offset: 0x85BCB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC18createTextureCacheSo017CVOpenGLESTextureF3RefaSgyFZ', symObjAddr: 0x0, symBinAddr: 0x10DC0, symSize: 0xA4 }
+  - { offsetInCU: 0xAAA, offset: 0x85C61, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11createImageySo11CVBufferRefaSgSo022CVOpenGLESTextureCacheG0a_AFSo012CFDictionaryG0aSgs6UInt32Vs5Int32VA2p2NSitFZ', symObjAddr: 0x148, symBinAddr: 0x10F08, symSize: 0x90 }
+  - { offsetInCU: 0xC31, offset: 0x85DE8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11setupRenderAA9NSCRenderCyFZ', symObjAddr: 0x2E8, symBinAddr: 0x110A8, symSize: 0x24 }
+  - { offsetInCU: 0xC7B, offset: 0x85E32, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC9drawFrameyySo8AVPlayerC_So0F15ItemVideoOutputCSo6CGSizeVAA9NSCRenderCs5Int32VANSbtFZ', symObjAddr: 0x334, symBinAddr: 0x110F4, symSize: 0x4 }
+  - { offsetInCU: 0xC9D, offset: 0x85E54, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11writeToFileyySo6NSDataC_SStKFZ', symObjAddr: 0x3E8, symBinAddr: 0x111A8, symSize: 0xE8 }
+  - { offsetInCU: 0xD4D, offset: 0x85F04, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCACycfC', symObjAddr: 0x62C, symBinAddr: 0x113EC, symSize: 0x20 }
+  - { offsetInCU: 0xD61, offset: 0x85F18, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCACycfc', symObjAddr: 0x64C, symBinAddr: 0x1140C, symSize: 0x30 }
+  - { offsetInCU: 0xD97, offset: 0x85F4E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCfD', symObjAddr: 0x6B8, symBinAddr: 0x11478, symSize: 0x30 }
+  - { offsetInCU: 0x27, offset: 0x86067, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x0, symBinAddr: 0x11A9C, symSize: 0x4 }
+  - { offsetInCU: 0x71, offset: 0x860B1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZTo', symObjAddr: 0x4, symBinAddr: 0x11AA0, symSize: 0x70 }
+  - { offsetInCU: 0xF6, offset: 0x86136, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS2ftFZTo', symObjAddr: 0x78, symBinAddr: 0x11B14, symSize: 0x50 }
+  - { offsetInCU: 0x191, offset: 0x861D1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS4ftFZTo', symObjAddr: 0xCC, symBinAddr: 0x11B68, symSize: 0x68 }
+  - { offsetInCU: 0x254, offset: 0x86294, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS8ftFZTo', symObjAddr: 0x138, symBinAddr: 0x11BD4, symSize: 0x98 }
+  - { offsetInCU: 0x323, offset: 0x86363, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCACycfcTo', symObjAddr: 0x220, symBinAddr: 0x11CBC, symSize: 0x3C }
+  - { offsetInCU: 0x375, offset: 0x863B5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCMa', symObjAddr: 0x28C, symBinAddr: 0x11D28, symSize: 0x20 }
+  - { offsetInCU: 0x4E5, offset: 0x86525, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x0, symBinAddr: 0x11A9C, symSize: 0x4 }
+  - { offsetInCU: 0x51D, offset: 0x8655D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x0, symBinAddr: 0x11A9C, symSize: 0x4 }
+  - { offsetInCU: 0x588, offset: 0x865C8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS2ftFZ', symObjAddr: 0x74, symBinAddr: 0x11B10, symSize: 0x4 }
+  - { offsetInCU: 0x5C8, offset: 0x86608, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS2ftFZ', symObjAddr: 0x74, symBinAddr: 0x11B10, symSize: 0x4 }
+  - { offsetInCU: 0x62A, offset: 0x8666A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS4ftFZ', symObjAddr: 0xC8, symBinAddr: 0x11B64, symSize: 0x4 }
+  - { offsetInCU: 0x67C, offset: 0x866BC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS4ftFZ', symObjAddr: 0xC8, symBinAddr: 0x11B64, symSize: 0x4 }
+  - { offsetInCU: 0x6F1, offset: 0x86731, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS8ftFZ', symObjAddr: 0x134, symBinAddr: 0x11BD0, symSize: 0x4 }
+  - { offsetInCU: 0x767, offset: 0x867A7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS8ftFZ', symObjAddr: 0x134, symBinAddr: 0x11BD0, symSize: 0x4 }
+  - { offsetInCU: 0x805, offset: 0x86845, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCACycfC', symObjAddr: 0x1D0, symBinAddr: 0x11C6C, symSize: 0x20 }
+  - { offsetInCU: 0x819, offset: 0x86859, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCACycfc', symObjAddr: 0x1F0, symBinAddr: 0x11C8C, symSize: 0x30 }
+  - { offsetInCU: 0x84F, offset: 0x8688F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCfD', symObjAddr: 0x25C, symBinAddr: 0x11CF8, symSize: 0x30 }
+  - { offsetInCU: 0x27, offset: 0x868D9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC10texImage2Dyys5Int64V_s5Int32VA4HSpys5UInt8VGSuSo6CGSizeVSbtFZ', symObjAddr: 0x0, symBinAddr: 0x11D48, symSize: 0x14 }
+  - { offsetInCU: 0xA9, offset: 0x8695B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC10texImage2Dyys5Int64V_s5Int32VA4HSpys5UInt8VGSuSo6CGSizeVSbtFZTo', symObjAddr: 0x14, symBinAddr: 0x11D5C, symSize: 0x38 }
+  - { offsetInCU: 0x1A2, offset: 0x86A54, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC13texSubImage2Dyys5Int64V_s5Int32VA5HSpys5UInt8VGSuSo6CGSizeVSbtFZTo', symObjAddr: 0x68, symBinAddr: 0x11DB0, symSize: 0x40 }
+  - { offsetInCU: 0x284, offset: 0x86B36, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCACycfcTo', symObjAddr: 0x118, symBinAddr: 0x11E60, symSize: 0x3C }
+  - { offsetInCU: 0x2D6, offset: 0x86B88, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCMa', symObjAddr: 0xF8, symBinAddr: 0x11E40, symSize: 0x20 }
+  - { offsetInCU: 0x480, offset: 0x86D32, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC10texImage2Dyys5Int64V_s5Int32VA4HSpys5UInt8VGSuSo6CGSizeVSbtFZ', symObjAddr: 0x0, symBinAddr: 0x11D48, symSize: 0x14 }
+  - { offsetInCU: 0x5C4, offset: 0x86E76, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC13texSubImage2Dyys5Int64V_s5Int32VA5HSpys5UInt8VGSuSo6CGSizeVSbtFZ', symObjAddr: 0x4C, symBinAddr: 0x11D94, symSize: 0x1C }
+  - { offsetInCU: 0x6FA, offset: 0x86FAC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCACycfC', symObjAddr: 0xA8, symBinAddr: 0x11DF0, symSize: 0x20 }
+  - { offsetInCU: 0x70E, offset: 0x86FC0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCACycfc', symObjAddr: 0xC8, symBinAddr: 0x11E10, symSize: 0x30 }
+  - { offsetInCU: 0x744, offset: 0x86FF6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCfD', symObjAddr: 0x154, symBinAddr: 0x11E9C, symSize: 0x30 }
+  - { offsetInCU: 0x61, offset: 0x8707A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7isDirtySbvgTo', symObjAddr: 0x4, symBinAddr: 0x11ED0, symSize: 0x10 }
+  - { offsetInCU: 0x81, offset: 0x8709A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7isDirtySbvgTo', symObjAddr: 0x4, symBinAddr: 0x11ED0, symSize: 0x10 }
+  - { offsetInCU: 0xB7, offset: 0x870D0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7isDirtySbvsTo', symObjAddr: 0x14, symBinAddr: 0x11EE0, symSize: 0x10 }
+  - { offsetInCU: 0xD7, offset: 0x870F0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7isDirtySbvsTo', symObjAddr: 0x14, symBinAddr: 0x11EE0, symSize: 0x10 }
+  - { offsetInCU: 0x110, offset: 0x87129, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC6canvasAA9NSCCanvasCSgvgTo', symObjAddr: 0x24, symBinAddr: 0x11EF0, symSize: 0x48 }
+  - { offsetInCU: 0x168, offset: 0x87181, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC6canvasAA9NSCCanvasCSgvsTo', symObjAddr: 0xB4, symBinAddr: 0x11F80, symSize: 0x50 }
+  - { offsetInCU: 0x1C3, offset: 0x871DC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC3fbos6UInt32VvgTo', symObjAddr: 0x104, symBinAddr: 0x11FD0, symSize: 0x10 }
+  - { offsetInCU: 0x1E3, offset: 0x871FC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC3fbos6UInt32VvgTo', symObjAddr: 0x104, symBinAddr: 0x11FD0, symSize: 0x10 }
+  - { offsetInCU: 0x219, offset: 0x87232, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC3fbos6UInt32VvsTo', symObjAddr: 0x114, symBinAddr: 0x11FE0, symSize: 0x10 }
+  - { offsetInCU: 0x239, offset: 0x87252, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC3fbos6UInt32VvsTo', symObjAddr: 0x114, symBinAddr: 0x11FE0, symSize: 0x10 }
+  - { offsetInCU: 0x272, offset: 0x8728B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCACycfcTo', symObjAddr: 0x1B0, symBinAddr: 0x1207C, symSize: 0x78 }
+  - { offsetInCU: 0x2C8, offset: 0x872E1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frameACSo6CGRectV_tcfcTo', symObjAddr: 0x2D4, symBinAddr: 0x121A0, symSize: 0xB0 }
+  - { offsetInCU: 0x32A, offset: 0x87343, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5coderACSgSo7NSCoderC_tcfcTo', symObjAddr: 0x43C, symBinAddr: 0x12308, symSize: 0x28 }
+  - { offsetInCU: 0x35C, offset: 0x87375, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC12bindDrawableyyFTo', symObjAddr: 0x4E0, symBinAddr: 0x12330, symSize: 0xA0 }
+  - { offsetInCU: 0x3DD, offset: 0x873F6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC14deleteDrawableyyFTo', symObjAddr: 0x5BC, symBinAddr: 0x123D0, symSize: 0x60 }
+  - { offsetInCU: 0x44D, offset: 0x87466, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7glkView_6drawInySo0C0C_So6CGRectVtFTo', symObjAddr: 0x620, symBinAddr: 0x12434, symSize: 0x4C }
+  - { offsetInCU: 0x4BF, offset: 0x874D8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frame7contextACSo6CGRectV_So11EAGLContextCtcfcTo', symObjAddr: 0x70C, symBinAddr: 0x12520, symSize: 0x34 }
+  - { offsetInCU: 0x533, offset: 0x8754C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCMa', symObjAddr: 0x190, symBinAddr: 0x1205C, symSize: 0x20 }
+  - { offsetInCU: 0x55D, offset: 0x87576, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCfETo', symObjAddr: 0x74C, symBinAddr: 0x12560, symSize: 0x10 }
+  - { offsetInCU: 0x65B, offset: 0x87674, size: 0x8, addend: 0x0, symName: '_$sSo7GLKViewC12CanvasNativeE16snapshotWithDatayy10Foundation0F0VFTo', symObjAddr: 0xA08, symBinAddr: 0x1281C, symSize: 0x74 }
+  - { offsetInCU: 0x699, offset: 0x876B2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC7isDirtySbvgTo', symObjAddr: 0xA7C, symBinAddr: 0x12890, symSize: 0x10 }
+  - { offsetInCU: 0x6B9, offset: 0x876D2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC7isDirtySbvgTo', symObjAddr: 0xA7C, symBinAddr: 0x12890, symSize: 0x10 }
+  - { offsetInCU: 0x6EF, offset: 0x87708, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC7isDirtySbvsTo', symObjAddr: 0xA8C, symBinAddr: 0x128A0, symSize: 0x10 }
+  - { offsetInCU: 0x70F, offset: 0x87728, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC7isDirtySbvsTo', symObjAddr: 0xA8C, symBinAddr: 0x128A0, symSize: 0x10 }
+  - { offsetInCU: 0x748, offset: 0x87761, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC8rendererAA9NSCCanvasCSgvgTo', symObjAddr: 0xA9C, symBinAddr: 0x128B0, symSize: 0x20 }
+  - { offsetInCU: 0x7A0, offset: 0x877B9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC8rendererAA9NSCCanvasCSgvsTo', symObjAddr: 0xABC, symBinAddr: 0x128D0, symSize: 0x14 }
+  - { offsetInCU: 0x7FB, offset: 0x87814, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvgTo', symObjAddr: 0xAD0, symBinAddr: 0x128E4, symSize: 0x44 }
+  - { offsetInCU: 0x853, offset: 0x8786C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvsTo', symObjAddr: 0xB58, symBinAddr: 0x1296C, symSize: 0x48 }
+  - { offsetInCU: 0x8E8, offset: 0x87901, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCACycfcTo', symObjAddr: 0xCBC, symBinAddr: 0x12AD0, symSize: 0x78 }
+  - { offsetInCU: 0x93E, offset: 0x87957, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5frameACSo6CGRectV_tcfcTo', symObjAddr: 0xE34, symBinAddr: 0x12C48, symSize: 0xB0 }
+  - { offsetInCU: 0x9A0, offset: 0x879B9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5coderACSgSo7NSCoderC_tcfcTo', symObjAddr: 0xF90, symBinAddr: 0x12DA4, symSize: 0x28 }
+  - { offsetInCU: 0x9D2, offset: 0x879EB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC11deviceScaleSfyFTo', symObjAddr: 0xFB8, symBinAddr: 0x12DCC, symSize: 0xB8 }
+  - { offsetInCU: 0xA53, offset: 0x87A6C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC4drawyySo6CGRectVFTo', symObjAddr: 0x1074, symBinAddr: 0x12E84, symSize: 0x28 }
+  - { offsetInCU: 0xAB1, offset: 0x87ACA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCfETo', symObjAddr: 0x10D8, symBinAddr: 0x12EE8, symSize: 0x10 }
+  - { offsetInCU: 0xC88, offset: 0x87CA1, size: 0x8, addend: 0x0, symName: '_$ss22_ContiguousArrayBufferV19_uninitializedCount15minimumCapacityAByxGSi_SitcfCs5UInt8V_Tgmq5', symObjAddr: 0x13D0, symBinAddr: 0x130E4, symSize: 0x64 }
+  - { offsetInCU: 0xCD9, offset: 0x87CF2, size: 0x8, addend: 0x0, symName: '_$s10Foundation4DataV15_RepresentationOWOy', symObjAddr: 0x15D8, symBinAddr: 0x132EC, symSize: 0x44 }
+  - { offsetInCU: 0xCED, offset: 0x87D06, size: 0x8, addend: 0x0, symName: '_$s10Foundation4DataV15_RepresentationOWOe', symObjAddr: 0x161C, symBinAddr: 0x13330, symSize: 0x44 }
+  - { offsetInCU: 0xD01, offset: 0x87D1A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCMa', symObjAddr: 0x1660, symBinAddr: 0x13374, symSize: 0x20 }
+  - { offsetInCU: 0xDDB, offset: 0x87DF4, size: 0x8, addend: 0x0, symName: '_$sSaySayxGqd__c7ElementQyd__RszSTRd__lufCs5UInt8V_10Foundation4DataVTgm5Tf4g_n', symObjAddr: 0x14B8, symBinAddr: 0x131CC, symSize: 0x110 }
+  - { offsetInCU: 0x1086, offset: 0x8809F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC6canvasAA9NSCCanvasCSgvg', symObjAddr: 0x6C, symBinAddr: 0x11F38, symSize: 0x48 }
+  - { offsetInCU: 0x1103, offset: 0x8811C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCACycfc', symObjAddr: 0x124, symBinAddr: 0x11FF0, symSize: 0x6C }
+  - { offsetInCU: 0x114A, offset: 0x88163, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frameACSo6CGRectV_tcfc', symObjAddr: 0x228, symBinAddr: 0x120F4, symSize: 0xAC }
+  - { offsetInCU: 0x11AE, offset: 0x881C7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5coderACSgSo7NSCoderC_tcfc', symObjAddr: 0x384, symBinAddr: 0x12250, symSize: 0xB8 }
+  - { offsetInCU: 0x1239, offset: 0x88252, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7glkView_6drawInySo0C0C_So6CGRectVtF', symObjAddr: 0x61C, symBinAddr: 0x12430, symSize: 0x4 }
+  - { offsetInCU: 0x125A, offset: 0x88273, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frame7contextACSo6CGRectV_So11EAGLContextCtcfC', symObjAddr: 0x66C, symBinAddr: 0x12480, symSize: 0x74 }
+  - { offsetInCU: 0x126E, offset: 0x88287, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frame7contextACSo6CGRectV_So11EAGLContextCtcfc', symObjAddr: 0x6E0, symBinAddr: 0x124F4, symSize: 0x2C }
+  - { offsetInCU: 0x1387, offset: 0x883A0, size: 0x8, addend: 0x0, symName: '_$sSo7GLKViewC12CanvasNativeE16snapshotWithDatayy10Foundation0F0VF', symObjAddr: 0x75C, symBinAddr: 0x12570, symSize: 0x2AC }
+  - { offsetInCU: 0x1731, offset: 0x8874A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvg', symObjAddr: 0xB14, symBinAddr: 0x12928, symSize: 0x44 }
+  - { offsetInCU: 0x1770, offset: 0x88789, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvs', symObjAddr: 0xBA0, symBinAddr: 0x129B4, symSize: 0x48 }
+  - { offsetInCU: 0x1795, offset: 0x887AE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvM', symObjAddr: 0xBE8, symBinAddr: 0x129FC, symSize: 0x44 }
+  - { offsetInCU: 0x17BA, offset: 0x887D3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvM.resume.0', symObjAddr: 0xC2C, symBinAddr: 0x12A40, symSize: 0x4 }
+  - { offsetInCU: 0x17E1, offset: 0x887FA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCACycfC', symObjAddr: 0xC30, symBinAddr: 0x12A44, symSize: 0x20 }
+  - { offsetInCU: 0x17F5, offset: 0x8880E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCACycfc', symObjAddr: 0xC50, symBinAddr: 0x12A64, symSize: 0x6C }
+  - { offsetInCU: 0x183C, offset: 0x88855, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5frameACSo6CGRectV_tcfc', symObjAddr: 0xD88, symBinAddr: 0x12B9C, symSize: 0xAC }
+  - { offsetInCU: 0x189B, offset: 0x888B4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5coderACSgSo7NSCoderC_tcfc', symObjAddr: 0xEE4, symBinAddr: 0x12CF8, symSize: 0xAC }
+  - { offsetInCU: 0x1940, offset: 0x88959, size: 0x8, addend: 0x0, symName: '_$ss12_ArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtF12CanvasNative15NSCTouchHandlerC7PointerV_Tg5', symObjAddr: 0x10E8, symBinAddr: 0x12EF8, symSize: 0x104 }
+  - { offsetInCU: 0x1A6F, offset: 0x88A88, size: 0x8, addend: 0x0, symName: '_$ss12_ArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtFs5UInt8V_Tg5', symObjAddr: 0x12E8, symBinAddr: 0x12FFC, symSize: 0xE8 }
+  - { offsetInCU: 0x1BB3, offset: 0x88BCC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7glkView_6drawInySo0C0C_So6CGRectVtFTf4ddn_n', symObjAddr: 0x1434, symBinAddr: 0x13148, symSize: 0x84 }
+  - { offsetInCU: 0x1CAC, offset: 0x88CC5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC4drawyySo6CGRectVFTf4dn_n', symObjAddr: 0x1680, symBinAddr: 0x13394, symSize: 0x360 }
+  - { offsetInCU: 0x2B, offset: 0x890DF, size: 0x8, addend: 0x0, symName: '_$sIegh_IeyBh_TR', symObjAddr: 0x0, symBinAddr: 0x138E0, symSize: 0x2C }
+  - { offsetInCU: 0x4F, offset: 0x89103, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC5queue33_7ED578B0ED4B2B6F6887A622A7B49AA3LLSo012OS_dispatch_E0CvpZ', symObjAddr: 0x958, symBinAddr: 0x11501C0, symSize: 0x0 }
+  - { offsetInCU: 0x5D, offset: 0x89111, size: 0x8, addend: 0x0, symName: '_$sIegh_IeyBh_TR', symObjAddr: 0x0, symBinAddr: 0x138E0, symSize: 0x2C }
+  - { offsetInCU: 0x75, offset: 0x89129, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC5queue33_7ED578B0ED4B2B6F6887A622A7B49AA3LL_WZ', symObjAddr: 0x2C, symBinAddr: 0x1390C, symSize: 0x10C }
+  - { offsetInCU: 0xBC, offset: 0x89170, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF4SyncySbs5Int64V_So7UIImageCtFZTo', symObjAddr: 0x13C, symBinAddr: 0x13A1C, symSize: 0x44 }
+  - { offsetInCU: 0x132, offset: 0x891E6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZTo', symObjAddr: 0x3AC, symBinAddr: 0x13C8C, symSize: 0x80 }
+  - { offsetInCU: 0x191, offset: 0x89245, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCACycfcTo', symObjAddr: 0x47C, symBinAddr: 0x13D5C, symSize: 0x3C }
+  - { offsetInCU: 0x1E2, offset: 0x89296, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZTf4nnnd_n', symObjAddr: 0x4EC, symBinAddr: 0x13DCC, symSize: 0x1DC }
+  - { offsetInCU: 0x269, offset: 0x8931D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCfETo', symObjAddr: 0x4E8, symBinAddr: 0x13DC8, symSize: 0x4 }
+  - { offsetInCU: 0x2A5, offset: 0x89359, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCMa', symObjAddr: 0x6C8, symBinAddr: 0x13FA8, symSize: 0x20 }
+  - { offsetInCU: 0x2C4, offset: 0x89378, size: 0x8, addend: 0x0, symName: '_$s10ObjectiveC8ObjCBoolVIeyBy_SbIegy_TRTA', symObjAddr: 0x70C, symBinAddr: 0x13FEC, symSize: 0x14 }
+  - { offsetInCU: 0x2ED, offset: 0x893A1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_TA', symObjAddr: 0x74C, symBinAddr: 0x1402C, symSize: 0xC }
+  - { offsetInCU: 0x301, offset: 0x893B5, size: 0x8, addend: 0x0, symName: _block_copy_helper, symObjAddr: 0x758, symBinAddr: 0x14038, symSize: 0x10 }
+  - { offsetInCU: 0x315, offset: 0x893C9, size: 0x8, addend: 0x0, symName: _block_destroy_helper, symObjAddr: 0x768, symBinAddr: 0x14048, symSize: 0x8 }
+  - { offsetInCU: 0x329, offset: 0x893DD, size: 0x8, addend: 0x0, symName: '_$s8Dispatch0A13WorkItemFlagsVACs10SetAlgebraAAWl', symObjAddr: 0x770, symBinAddr: 0x14050, symSize: 0x48 }
+  - { offsetInCU: 0x33D, offset: 0x893F1, size: 0x8, addend: 0x0, symName: '_$sSay8Dispatch0A13WorkItemFlagsVGSayxGSTsWl', symObjAddr: 0x7F8, symBinAddr: 0x14098, symSize: 0x4C }
+  - { offsetInCU: 0x351, offset: 0x89405, size: 0x8, addend: 0x0, symName: ___swift_instantiateConcreteTypeFromMangledNameAbstract, symObjAddr: 0x844, symBinAddr: 0x140E4, symSize: 0x44 }
+  - { offsetInCU: 0x365, offset: 0x89419, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_yyScMYccfU0_TA', symObjAddr: 0x8C4, symBinAddr: 0x14128, symSize: 0x24 }
+  - { offsetInCU: 0x399, offset: 0x8944D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_yyScMYccfU_TA', symObjAddr: 0x90C, symBinAddr: 0x14170, symSize: 0x24 }
+  - { offsetInCU: 0x52E, offset: 0x895E2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF4SyncySbs5Int64V_So7UIImageCtFZ', symObjAddr: 0x138, symBinAddr: 0x13A18, symSize: 0x4 }
+  - { offsetInCU: 0x55C, offset: 0x89610, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF4SyncySbs5Int64V_So7UIImageCtFZ', symObjAddr: 0x138, symBinAddr: 0x13A18, symSize: 0x4 }
+  - { offsetInCU: 0x5BB, offset: 0x8966F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZ', symObjAddr: 0x180, symBinAddr: 0x13A60, symSize: 0x4 }
+  - { offsetInCU: 0x5CF, offset: 0x89683, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_', symObjAddr: 0x184, symBinAddr: 0x13A64, symSize: 0x228 }
+  - { offsetInCU: 0x6A8, offset: 0x8975C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCACycfC', symObjAddr: 0x42C, symBinAddr: 0x13D0C, symSize: 0x20 }
+  - { offsetInCU: 0x6BC, offset: 0x89770, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCACycfc', symObjAddr: 0x44C, symBinAddr: 0x13D2C, symSize: 0x30 }
+  - { offsetInCU: 0x6F2, offset: 0x897A6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCfD', symObjAddr: 0x4B8, symBinAddr: 0x13D98, symSize: 0x30 }
+  - { offsetInCU: 0x27, offset: 0x8984C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfC', symObjAddr: 0x0, symBinAddr: 0x141A8, symSize: 0x20 }
+  - { offsetInCU: 0x77, offset: 0x8989C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfcTo', symObjAddr: 0x70, symBinAddr: 0x14218, symSize: 0x3C }
+  - { offsetInCU: 0xC9, offset: 0x898EE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCMa', symObjAddr: 0x50, symBinAddr: 0x141F8, symSize: 0x20 }
+  - { offsetInCU: 0x214, offset: 0x89A39, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfC', symObjAddr: 0x0, symBinAddr: 0x141A8, symSize: 0x20 }
+  - { offsetInCU: 0x228, offset: 0x89A4D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfc', symObjAddr: 0x20, symBinAddr: 0x141C8, symSize: 0x30 }
+  - { offsetInCU: 0x264, offset: 0x89A89, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCfD', symObjAddr: 0xAC, symBinAddr: 0x14254, symSize: 0x30 }
+  - { offsetInCU: 0x26, offset: 0x89AD2, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_frombytes_vartime, symObjAddr: 0x0, symBinAddr: 0x327A64, symSize: 0x265C }
+  - { offsetInCU: 0x40, offset: 0x89AEC, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_k25519Precomp, symObjAddr: 0x9E20, symBinAddr: 0xA19170, symSize: 0x0 }
+  - { offsetInCU: 0x92, offset: 0x89B3E, size: 0x8, addend: 0x0, symName: _d, symObjAddr: 0xFE20, symBinAddr: 0xA1F170, symSize: 0x0 }
+  - { offsetInCU: 0xF6, offset: 0x89BA2, size: 0x8, addend: 0x0, symName: _sqrtm1, symObjAddr: 0xFE48, symBinAddr: 0xA1F198, symSize: 0x0 }
+  - { offsetInCU: 0x10C, offset: 0x89BB8, size: 0x8, addend: 0x0, symName: _d2, symObjAddr: 0x10250, symBinAddr: 0xA1F5A0, symSize: 0x0 }
+  - { offsetInCU: 0x123, offset: 0x89BCF, size: 0x8, addend: 0x0, symName: _Bi, symObjAddr: 0xFE90, symBinAddr: 0xA1F1E0, symSize: 0x0 }
+  - { offsetInCU: 0x9C2, offset: 0x8A46E, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_frombytes_vartime, symObjAddr: 0x0, symBinAddr: 0x327A64, symSize: 0x265C }
+  - { offsetInCU: 0x45D1, offset: 0x8E07D, size: 0x8, addend: 0x0, symName: _fe_frombytes, symObjAddr: 0x265C, symBinAddr: 0x32A0C0, symSize: 0x134 }
+  - { offsetInCU: 0x46F7, offset: 0x8E1A3, size: 0x8, addend: 0x0, symName: _fe_mul_impl, symObjAddr: 0x9954, symBinAddr: 0x3313B8, symSize: 0x21C }
+  - { offsetInCU: 0x4926, offset: 0x8E3D2, size: 0x8, addend: 0x0, symName: _fe_tobytes, symObjAddr: 0x4FE0, symBinAddr: 0x32CA44, symSize: 0x1B8 }
+  - { offsetInCU: 0x5313, offset: 0x8EDBF, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_scalarmult_base, symObjAddr: 0x2790, symBinAddr: 0x32A1F4, symSize: 0x5BC }
+  - { offsetInCU: 0x5F76, offset: 0x8FA22, size: 0x8, addend: 0x0, symName: _table_select, symObjAddr: 0x2D4C, symBinAddr: 0x32A7B0, symSize: 0x7F8 }
+  - { offsetInCU: 0x642E, offset: 0x8FEDA, size: 0x8, addend: 0x0, symName: _ge_madd, symObjAddr: 0x3544, symBinAddr: 0x32AFA8, symSize: 0x208 }
+  - { offsetInCU: 0x69FC, offset: 0x904A8, size: 0x8, addend: 0x0, symName: _ge_p2_dbl, symObjAddr: 0x374C, symBinAddr: 0x32B1B0, symSize: 0x7B4 }
+  - { offsetInCU: 0x77D5, offset: 0x91281, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_sc_reduce, symObjAddr: 0x3F00, symBinAddr: 0x32B964, symSize: 0x634 }
+  - { offsetInCU: 0x8196, offset: 0x91C42, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_scalar_mult_generic_masked, symObjAddr: 0x4534, symBinAddr: 0x32BF98, symSize: 0xAAC }
+  - { offsetInCU: 0x9567, offset: 0x93013, size: 0x8, addend: 0x0, symName: _fe_loose_invert, symObjAddr: 0x529C, symBinAddr: 0x32CD00, symSize: 0x23F8 }
+  - { offsetInCU: 0xCAB8, offset: 0x96564, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_public_from_private_generic_masked, symObjAddr: 0x5198, symBinAddr: 0x32CBFC, symSize: 0x104 }
+  - { offsetInCU: 0xCD20, offset: 0x967CC, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_invert, symObjAddr: 0x7694, symBinAddr: 0x32F0F8, symSize: 0x30 }
+  - { offsetInCU: 0xCE11, offset: 0x968BD, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_isnegative, symObjAddr: 0x76C4, symBinAddr: 0x32F128, symSize: 0x58 }
+  - { offsetInCU: 0xCE86, offset: 0x96932, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_mul_ttt, symObjAddr: 0x771C, symBinAddr: 0x32F180, symSize: 0x4 }
+  - { offsetInCU: 0xCECE, offset: 0x9697A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_mul_ttt, symObjAddr: 0x771C, symBinAddr: 0x32F180, symSize: 0x4 }
+  - { offsetInCU: 0xCEFD, offset: 0x969A9, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_mul_ttt, symObjAddr: 0x771C, symBinAddr: 0x32F180, symSize: 0x4 }
+  - { offsetInCU: 0xCF21, offset: 0x969CD, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_neg, symObjAddr: 0x7720, symBinAddr: 0x32F184, symSize: 0x8C }
+  - { offsetInCU: 0xD056, offset: 0x96B02, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_tobytes, symObjAddr: 0x77AC, symBinAddr: 0x32F210, symSize: 0x4 }
+  - { offsetInCU: 0xD08F, offset: 0x96B3B, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_tobytes, symObjAddr: 0x77AC, symBinAddr: 0x32F210, symSize: 0x4 }
+  - { offsetInCU: 0xD328, offset: 0x96DD4, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_double_scalarmult_vartime, symObjAddr: 0x77B0, symBinAddr: 0x32F214, symSize: 0x15D8 }
+  - { offsetInCU: 0x10671, offset: 0x9A11D, size: 0x8, addend: 0x0, symName: _x25519_ge_add, symObjAddr: 0x9B70, symBinAddr: 0x3315D4, symSize: 0x218 }
+  - { offsetInCU: 0x10CA3, offset: 0x9A74F, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_sc_mask, symObjAddr: 0x8D88, symBinAddr: 0x3307EC, symSize: 0x20 }
+  - { offsetInCU: 0x11140, offset: 0x9ABEC, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_sc_muladd, symObjAddr: 0x8DA8, symBinAddr: 0x33080C, symSize: 0xBAC }
+  - { offsetInCU: 0x26, offset: 0x9B9B7, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_from_montgomery_in_place, symObjAddr: 0x0, symBinAddr: 0x3317EC, symSize: 0x1F4 }
+  - { offsetInCU: 0x1D2, offset: 0x9BB63, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_from_montgomery_in_place, symObjAddr: 0x0, symBinAddr: 0x3317EC, symSize: 0x1F4 }
+  - { offsetInCU: 0x26, offset: 0x9BDFE, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_neg_inv_mod_r_u64, symObjAddr: 0x0, symBinAddr: 0x3319E0, symSize: 0x3C }
+  - { offsetInCU: 0x34, offset: 0x9BE0C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_neg_inv_mod_r_u64, symObjAddr: 0x0, symBinAddr: 0x3319E0, symSize: 0x3C }
+  - { offsetInCU: 0x26, offset: 0x9BF1C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_little_endian_bytes_from_scalar, symObjAddr: 0x0, symBinAddr: 0x331A1C, symSize: 0x98 }
+  - { offsetInCU: 0x34, offset: 0x9BF2A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_little_endian_bytes_from_scalar, symObjAddr: 0x0, symBinAddr: 0x331A1C, symSize: 0x98 }
+  - { offsetInCU: 0x86, offset: 0x9C08D, size: 0x8, addend: 0x0, symName: _Q_N0, symObjAddr: 0x1100, symBinAddr: 0xA1F650, symSize: 0x0 }
+  - { offsetInCU: 0xB8, offset: 0x9C0BF, size: 0x8, addend: 0x0, symName: _Q, symObjAddr: 0x1090, symBinAddr: 0xA1F5E0, symSize: 0x0 }
+  - { offsetInCU: 0xDA, offset: 0x9C0E1, size: 0x8, addend: 0x0, symName: _N, symObjAddr: 0x10C0, symBinAddr: 0xA1F610, symSize: 0x0 }
+  - { offsetInCU: 0xF0, offset: 0x9C0F7, size: 0x8, addend: 0x0, symName: _N_N0, symObjAddr: 0x10F0, symBinAddr: 0xA1F640, symSize: 0x0 }
+  - { offsetInCU: 0x3B7, offset: 0x9C3BE, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_elem_mul_mont, symObjAddr: 0x100, symBinAddr: 0x331AB4, symSize: 0x18 }
+  - { offsetInCU: 0x3FB, offset: 0x9C402, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_elem_mul_mont, symObjAddr: 0x100, symBinAddr: 0x331AB4, symSize: 0x18 }
+  - { offsetInCU: 0x594, offset: 0x9C59B, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_scalar_mul_mont, symObjAddr: 0x1F8, symBinAddr: 0x331ACC, symSize: 0x18 }
+  - { offsetInCU: 0x63F, offset: 0x9C646, size: 0x8, addend: 0x0, symName: _nistz384_point_double, symObjAddr: 0x290, symBinAddr: 0x331AE4, symSize: 0x320 }
+  - { offsetInCU: 0x1173, offset: 0x9D17A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_point_add, symObjAddr: 0x5B0, symBinAddr: 0x331E04, symSize: 0xAC }
+  - { offsetInCU: 0x1469, offset: 0x9D470, size: 0x8, addend: 0x0, symName: _nistz384_point_add, symObjAddr: 0x65C, symBinAddr: 0x331EB0, symSize: 0x500 }
+  - { offsetInCU: 0x2666, offset: 0x9E66D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_point_mul, symObjAddr: 0xB5C, symBinAddr: 0x3323B0, symSize: 0x2C8 }
+  - { offsetInCU: 0x2CB5, offset: 0x9ECBC, size: 0x8, addend: 0x0, symName: _p384_point_select_w5, symObjAddr: 0xE24, symBinAddr: 0x332678, symSize: 0xF4 }
+  - { offsetInCU: 0x2EC7, offset: 0x9EECE, size: 0x8, addend: 0x0, symName: _add_precomputed_w5, symObjAddr: 0xF18, symBinAddr: 0x33276C, symSize: 0x168 }
+  - { offsetInCU: 0x26, offset: 0x9F1F9, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_zero, symObjAddr: 0x0, symBinAddr: 0x3328D4, symSize: 0x38 }
+  - { offsetInCU: 0xFA, offset: 0x9F2CD, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_zero, symObjAddr: 0x0, symBinAddr: 0x3328D4, symSize: 0x38 }
+  - { offsetInCU: 0x12C, offset: 0x9F2FF, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_zero, symObjAddr: 0x0, symBinAddr: 0x3328D4, symSize: 0x38 }
+  - { offsetInCU: 0x199, offset: 0x9F36C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_equal, symObjAddr: 0x38, symBinAddr: 0x33290C, symSize: 0x3C }
+  - { offsetInCU: 0x1F3, offset: 0x9F3C6, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_equal, symObjAddr: 0x38, symBinAddr: 0x33290C, symSize: 0x3C }
+  - { offsetInCU: 0x31B, offset: 0x9F4EE, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_equal_limb, symObjAddr: 0x74, symBinAddr: 0x332948, symSize: 0x5C }
+  - { offsetInCU: 0x517, offset: 0x9F6EA, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_even, symObjAddr: 0xD0, symBinAddr: 0x3329A4, symSize: 0x1C }
+  - { offsetInCU: 0x636, offset: 0x9F809, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_less_than, symObjAddr: 0xEC, symBinAddr: 0x3329C0, symSize: 0x54 }
+  - { offsetInCU: 0x6D9, offset: 0x9F8AC, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_less_than_limb, symObjAddr: 0x140, symBinAddr: 0x332A14, symSize: 0x4C }
+  - { offsetInCU: 0x8A7, offset: 0x9FA7A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_reduce_once, symObjAddr: 0x18C, symBinAddr: 0x332A60, symSize: 0xA8 }
+  - { offsetInCU: 0x90B, offset: 0x9FADE, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_reduce_once, symObjAddr: 0x18C, symBinAddr: 0x332A60, symSize: 0xA8 }
+  - { offsetInCU: 0xBAA, offset: 0x9FD7D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_add_mod, symObjAddr: 0x234, symBinAddr: 0x332B08, symSize: 0x110 }
+  - { offsetInCU: 0xC4C, offset: 0x9FE1F, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_add_mod, symObjAddr: 0x234, symBinAddr: 0x332B08, symSize: 0x110 }
+  - { offsetInCU: 0xEDE, offset: 0xA00B1, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_sub_mod, symObjAddr: 0x344, symBinAddr: 0x332C18, symSize: 0xB0 }
+  - { offsetInCU: 0xF5E, offset: 0xA0131, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_sub_mod, symObjAddr: 0x344, symBinAddr: 0x332C18, symSize: 0xB0 }
+  - { offsetInCU: 0x10E1, offset: 0xA02B4, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_shl_mod, symObjAddr: 0x3F4, symBinAddr: 0x332CC8, symSize: 0x198 }
+  - { offsetInCU: 0x13AB, offset: 0xA057E, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_select_512_32, symObjAddr: 0x58C, symBinAddr: 0x332E60, symSize: 0x290 }
+  - { offsetInCU: 0x1500, offset: 0xA06D3, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_window5_split_window, symObjAddr: 0x81C, symBinAddr: 0x3330F0, symSize: 0x18 }
+  - { offsetInCU: 0x1567, offset: 0xA073A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_window5_unsplit_window, symObjAddr: 0x834, symBinAddr: 0x333108, symSize: 0xC }
+  - { offsetInCU: 0x15A0, offset: 0xA0773, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMB_shr, symObjAddr: 0x840, symBinAddr: 0x333114, symSize: 0x8 }
+  - { offsetInCU: 0x1624, offset: 0xA07F7, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_limbs_mul_add_limb, symObjAddr: 0x848, symBinAddr: 0x33311C, symSize: 0x3C }
+  - { offsetInCU: 0x26, offset: 0xA09AA, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_CRYPTO_memcmp, symObjAddr: 0x0, symBinAddr: 0x333158, symSize: 0x190 }
+  - { offsetInCU: 0x34, offset: 0xA09B8, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_CRYPTO_memcmp, symObjAddr: 0x0, symBinAddr: 0x333158, symSize: 0x190 }
+  - { offsetInCU: 0x34, offset: 0xA0ABE, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_OPENSSL_armcap_P, symObjAddr: 0x398, symBinAddr: 0x1157298, symSize: 0x0 }
+  - { offsetInCU: 0x26, offset: 0xA0B00, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul, symObjAddr: 0x0, symBinAddr: 0x3332E8, symSize: 0x388 }
+  - { offsetInCU: 0x76, offset: 0xA0B50, size: 0x8, addend: 0x0, symName: _ecp_nistz256_precomputed, symObjAddr: 0x1000, symBinAddr: 0xA20000, symSize: 0x0 }
+  - { offsetInCU: 0xFA, offset: 0xA0BD4, size: 0x8, addend: 0x0, symName: _ONE, symObjAddr: 0x26000, symBinAddr: 0xA45000, symSize: 0x0 }
+  - { offsetInCU: 0x35B, offset: 0xA0E35, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul, symObjAddr: 0x0, symBinAddr: 0x3332E8, symSize: 0x388 }
+  - { offsetInCU: 0xC66, offset: 0xA1740, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul_base, symObjAddr: 0x388, symBinAddr: 0x333670, symSize: 0x204 }
+  - { offsetInCU: 0x1163, offset: 0xA1C3D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul_base_vartime, symObjAddr: 0x58C, symBinAddr: 0x333874, symSize: 0x1BC }
+  - { offsetInCU: 0x10, offset: 0xA2012, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_set_encrypt_key, symObjAddr: 0x0, symBinAddr: 0x333A40, symSize: 0x1A0 }
+  - { offsetInCU: 0x50, offset: 0xA2052, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_set_encrypt_key, symObjAddr: 0x0, symBinAddr: 0x333A40, symSize: 0x1A0 }
+  - { offsetInCU: 0x5E, offset: 0xA2060, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_encrypt, symObjAddr: 0x1A0, symBinAddr: 0x333BE0, symSize: 0x60 }
+  - { offsetInCU: 0x81, offset: 0xA2083, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_ctr32_encrypt_blocks, symObjAddr: 0x200, symBinAddr: 0x333C40, symSize: 0x288 }
+  - { offsetInCU: 0x10, offset: 0xA2074, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_init_clmul, symObjAddr: 0x0, symBinAddr: 0x333ED0, symSize: 0x130 }
+  - { offsetInCU: 0x48, offset: 0xA20AC, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_init_clmul, symObjAddr: 0x0, symBinAddr: 0x333ED0, symSize: 0x130 }
+  - { offsetInCU: 0x5F, offset: 0xA20C3, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_gmult_clmul, symObjAddr: 0x130, symBinAddr: 0x334000, symSize: 0x70 }
+  - { offsetInCU: 0x75, offset: 0xA20D9, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_ghash_clmul, symObjAddr: 0x1A0, symBinAddr: 0x334070, symSize: 0x160 }
+  - { offsetInCU: 0x7A, offset: 0xA20DE, size: 0x8, addend: 0x0, symName: gcm_ghash_v8_4x, symObjAddr: 0x300, symBinAddr: 0x3341D0, symSize: 0x378 }
+  - { offsetInCU: 0x10, offset: 0xA20EC, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ChaCha20_ctr32, symObjAddr: 0x0, symBinAddr: 0x334560, symSize: 0x3A0 }
+  - { offsetInCU: 0x48, offset: 0xA2124, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ChaCha20_ctr32, symObjAddr: 0x0, symBinAddr: 0x334560, symSize: 0x3A0 }
+  - { offsetInCU: 0x4C, offset: 0xA2128, size: 0x8, addend: 0x0, symName: ChaCha20_neon, symObjAddr: 0x3A0, symBinAddr: 0x334900, symSize: 0x6C0 }
+  - { offsetInCU: 0x66, offset: 0xA2142, size: 0x8, addend: 0x0, symName: ChaCha20_512_neon, symObjAddr: 0xA60, symBinAddr: 0x334FC0, symSize: 0x1138 }
+  - { offsetInCU: 0x50, offset: 0xA218E, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_chacha20_poly1305_seal, symObjAddr: 0x140, symBinAddr: 0x336240, symSize: 0x1180 }
+  - { offsetInCU: 0x66, offset: 0xA21A4, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_chacha20_poly1305_open, symObjAddr: 0x12C0, symBinAddr: 0x3373C0, symSize: 0x1410 }
+  - { offsetInCU: 0x10, offset: 0xA219A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_mul_mont, symObjAddr: 0x0, symBinAddr: 0x3387E0, symSize: 0x240 }
+  - { offsetInCU: 0x45, offset: 0xA21CF, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_mul_mont, symObjAddr: 0x0, symBinAddr: 0x3387E0, symSize: 0x240 }
+  - { offsetInCU: 0x4D, offset: 0xA21D7, size: 0x8, addend: 0x0, symName: __bn_sqr8x_mont, symObjAddr: 0x240, symBinAddr: 0x338A20, symSize: 0x9E0 }
+  - { offsetInCU: 0x63, offset: 0xA21ED, size: 0x8, addend: 0x0, symName: __bn_mul4x_mont, symObjAddr: 0xC20, symBinAddr: 0x339400, symSize: 0x650 }
+  - { offsetInCU: 0x10, offset: 0xA21FC, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_mul_mont, symObjAddr: 0x0, symBinAddr: 0x339A60, symSize: 0x40 }
+  - { offsetInCU: 0x47, offset: 0xA2233, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_mul_mont, symObjAddr: 0x0, symBinAddr: 0x339A60, symSize: 0x40 }
+  - { offsetInCU: 0x5D, offset: 0xA2249, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_sqr_mont, symObjAddr: 0x40, symBinAddr: 0x339AA0, symSize: 0x40 }
+  - { offsetInCU: 0x76, offset: 0xA2262, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ecp_nistz256_neg, symObjAddr: 0x80, symBinAddr: 0x339AE0, symSize: 0x40 }
+  - { offsetInCU: 0x81, offset: 0xA226D, size: 0x8, addend: 0x0, symName: __ecp_nistz256_mul_mont, symObjAddr: 0xC0, symBinAddr: 0x339B20, symSize: 0x1E0 }
+  - { offsetInCU: 0x97, offset: 0xA2283, size: 0x8, addend: 0x0, symName: __ecp_nistz256_sqr_mont, symObjAddr: 0x2A0, symBinAddr: 0x339D00, symSize: 0x170 }
+  - { offsetInCU: 0xAB, offset: 0xA2297, size: 0x8, addend: 0x0, symName: __ecp_nistz256_add_to, symObjAddr: 0x410, symBinAddr: 0x339E70, symSize: 0x50 }
+  - { offsetInCU: 0xC3, offset: 0xA22AF, size: 0x8, addend: 0x0, symName: __ecp_nistz256_sub_from, symObjAddr: 0x460, symBinAddr: 0x339EC0, symSize: 0x50 }
+  - { offsetInCU: 0xD9, offset: 0xA22C5, size: 0x8, addend: 0x0, symName: __ecp_nistz256_sub_morf, symObjAddr: 0x4B0, symBinAddr: 0x339F10, symSize: 0x50 }
+  - { offsetInCU: 0xEF, offset: 0xA22DB, size: 0x8, addend: 0x0, symName: __ecp_nistz256_div_by_2, symObjAddr: 0x500, symBinAddr: 0x339F60, symSize: 0x60 }
+  - { offsetInCU: 0x111, offset: 0xA22FD, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_double, symObjAddr: 0x560, symBinAddr: 0x339FC0, symSize: 0x1E0 }
+  - { offsetInCU: 0x124, offset: 0xA2310, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_add, symObjAddr: 0x740, symBinAddr: 0x33A1A0, symSize: 0x360 }
+  - { offsetInCU: 0x141, offset: 0xA232D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_add_affine, symObjAddr: 0xAA0, symBinAddr: 0x33A500, symSize: 0x2D0 }
+  - { offsetInCU: 0x156, offset: 0xA2342, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_scalar_mul_mont, symObjAddr: 0xD70, symBinAddr: 0x33A7D0, symSize: 0x2B0 }
+  - { offsetInCU: 0x170, offset: 0xA235C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_scalar_sqr_rep_mont, symObjAddr: 0x1020, symBinAddr: 0x33AA80, symSize: 0x250 }
+  - { offsetInCU: 0x184, offset: 0xA2370, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ecp_nistz256_select_w5, symObjAddr: 0x1270, symBinAddr: 0x33ACD0, symSize: 0x60 }
+  - { offsetInCU: 0x19A, offset: 0xA2386, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ecp_nistz256_select_w7, symObjAddr: 0x12D0, symBinAddr: 0x33AD30, symSize: 0x44 }
+  - { offsetInCU: 0x10, offset: 0xA237C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_gcm_enc_kernel, symObjAddr: 0x0, symBinAddr: 0x33AD80, symSize: 0xB90 }
+  - { offsetInCU: 0x4C, offset: 0xA23B8, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_gcm_enc_kernel, symObjAddr: 0x0, symBinAddr: 0x33AD80, symSize: 0xB90 }
+  - { offsetInCU: 0x62, offset: 0xA23CE, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_gcm_dec_kernel, symObjAddr: 0xB90, symBinAddr: 0x33B910, symSize: 0xB98 }
+  - { offsetInCU: 0x10, offset: 0xA23C8, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha512_block_data_order, symObjAddr: 0x0, symBinAddr: 0x33C4C0, symSize: 0xE40 }
+  - { offsetInCU: 0x51, offset: 0xA2409, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha512_block_data_order, symObjAddr: 0x0, symBinAddr: 0x33C4C0, symSize: 0xE40 }
+  - { offsetInCU: 0x51, offset: 0xA2409, size: 0x8, addend: 0x0, symName: sha512_block_armv8, symObjAddr: 0xE40, symBinAddr: 0x33D300, symSize: 0x7E0 }
+  - { offsetInCU: 0x10, offset: 0xA2414, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha256_block_data_order, symObjAddr: 0x0, symBinAddr: 0x33DB00, symSize: 0xE40 }
+  - { offsetInCU: 0x51, offset: 0xA2455, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha256_block_data_order, symObjAddr: 0x0, symBinAddr: 0x33DB00, symSize: 0xE40 }
+  - { offsetInCU: 0x51, offset: 0xA2455, size: 0x8, addend: 0x0, symName: sha256_block_armv8, symObjAddr: 0xE40, symBinAddr: 0x33E940, symSize: 0x1F0 }
 ...
diff --git a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/Relocations/x86_64/CanvasNative.yml b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/Relocations/x86_64/CanvasNative.yml
index 0e5e3fa18..8788de0b8 100644
--- a/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/Relocations/x86_64/CanvasNative.yml
+++ b/packages/canvas/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/Relocations/x86_64/CanvasNative.yml
@@ -2,642 +2,642 @@
 triple:          'x86_64-apple-darwin'
 binary-path:     '/Users/triniwiz/Documents/GitHub/canvas/packages/canvas/src-native/canvas-ios/dist/Release-iphonesimulator/CanvasNative.framework/CanvasNative'
 relocations:
-  - { offsetInCU: 0x34, offset: 0x78EE9, size: 0x8, addend: 0x0, symName: _CanvasNativeVersionString, symObjAddr: 0x0, symBinAddr: 0xA1F000, symSize: 0x0 }
-  - { offsetInCU: 0x69, offset: 0x78F1E, size: 0x8, addend: 0x0, symName: _CanvasNativeVersionNumber, symObjAddr: 0x38, symBinAddr: 0xA1F038, symSize: 0x0 }
-  - { offsetInCU: 0x3F, offset: 0x78F73, size: 0x8, addend: 0x0, symName: ___swift_memcpy16_8, symObjAddr: 0x40, symBinAddr: 0x1D80, symSize: 0x10 }
-  - { offsetInCU: 0x53, offset: 0x78F87, size: 0x8, addend: 0x0, symName: ___swift_noop_void_return, symObjAddr: 0x50, symBinAddr: 0x1D90, symSize: 0x10 }
-  - { offsetInCU: 0x67, offset: 0x78F9B, size: 0x8, addend: 0x0, symName: '_$sSo6CGSizeVwet', symObjAddr: 0x60, symBinAddr: 0x1DA0, symSize: 0x20 }
-  - { offsetInCU: 0x7B, offset: 0x78FAF, size: 0x8, addend: 0x0, symName: '_$sSo6CGSizeVwst', symObjAddr: 0x80, symBinAddr: 0x1DC0, symSize: 0x30 }
-  - { offsetInCU: 0x8F, offset: 0x78FC3, size: 0x8, addend: 0x0, symName: '_$sSo6CGRectVwCP', symObjAddr: 0xD0, symBinAddr: 0x1E10, symSize: 0x30 }
-  - { offsetInCU: 0xA3, offset: 0x78FD7, size: 0x8, addend: 0x0, symName: ___swift_memcpy32_8, symObjAddr: 0x100, symBinAddr: 0x1E40, symSize: 0x20 }
-  - { offsetInCU: 0xB7, offset: 0x78FEB, size: 0x8, addend: 0x0, symName: '_$sSo6CGRectVwet', symObjAddr: 0x120, symBinAddr: 0x1E60, symSize: 0x20 }
-  - { offsetInCU: 0xCB, offset: 0x78FFF, size: 0x8, addend: 0x0, symName: '_$sSo6CGRectVwst', symObjAddr: 0x140, symBinAddr: 0x1E80, symSize: 0x30 }
-  - { offsetInCU: 0x4F, offset: 0x791E8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC11_WriteQueue33_05178D28796EA758448493B56DC45144LLSo011NSOperationE0CSgvpZ', symObjAddr: 0x30B0, symBinAddr: 0x12D2E60, symSize: 0x0 }
-  - { offsetInCU: 0x69, offset: 0x79202, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10_ReadQueue33_05178D28796EA758448493B56DC45144LLSo011NSOperationE0CSgvpZ', symObjAddr: 0x30B8, symBinAddr: 0x12D2E68, symSize: 0x0 }
-  - { offsetInCU: 0x9D, offset: 0x79236, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC19getBytesFromUIImageySo13NSMutableDataCSo0G0CFZTo', symObjAddr: 0x10, symBinAddr: 0x1F50, symSize: 0x40 }
-  - { offsetInCU: 0xF3, offset: 0x7928C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13createPatternys5Int64VAF_So7UIImageCSStFZTo', symObjAddr: 0x60, symBinAddr: 0x1FA0, symSize: 0x60 }
-  - { offsetInCU: 0x144, offset: 0x792DD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC25loadImageAssetWithContextySbs5Int64V_So7UIImageCtFZTo', symObjAddr: 0xD0, symBinAddr: 0x2010, symSize: 0x40 }
-  - { offsetInCU: 0x19F, offset: 0x79338, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dyys5Int64V_So7UIImageCS2ftFZTo', symObjAddr: 0x120, symBinAddr: 0x2060, symSize: 0x50 }
-  - { offsetInCU: 0x204, offset: 0x7939D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dy2dw2dhys5Int64V_So7UIImageCS4ftFZTo', symObjAddr: 0x180, symBinAddr: 0x20C0, symSize: 0x60 }
-  - { offsetInCU: 0x27D, offset: 0x79416, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2sx2sy2sw2sh2dx2dy2dw2dhys5Int64V_So7UIImageCS8ftFZTo', symObjAddr: 0x1F0, symBinAddr: 0x2130, symSize: 0x90 }
-  - { offsetInCU: 0x2DA, offset: 0x79473, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23initWebGPUWithViewLayerys5Int64VAF_AFs6UInt32VAHtFZTo', symObjAddr: 0x290, symBinAddr: 0x21D0, symSize: 0x20 }
-  - { offsetInCU: 0x35C, offset: 0x794F5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC18initWebGPUWithViewys5Int64VAF_AFs6UInt32VAHtFZTo', symObjAddr: 0x2C0, symBinAddr: 0x2200, symSize: 0x20 }
-  - { offsetInCU: 0x40B, offset: 0x795A4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14initGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbtFZTo', symObjAddr: 0x350, symBinAddr: 0x2290, symSize: 0x80 }
-  - { offsetInCU: 0x4D0, offset: 0x79669, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC20initSharedGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbAFtFZTo', symObjAddr: 0x440, symBinAddr: 0x2380, symSize: 0x80 }
-  - { offsetInCU: 0x59F, offset: 0x79738, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC24initGLWithWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbtFZTo', symObjAddr: 0x530, symBinAddr: 0x2470, symSize: 0x80 }
-  - { offsetInCU: 0x669, offset: 0x79802, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC26initSharedGLWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbAFtFZTo', symObjAddr: 0x630, symBinAddr: 0x2570, symSize: 0x90 }
-  - { offsetInCU: 0x701, offset: 0x7989A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15resize2DContextyys5Int64V_S2ftFZTo', symObjAddr: 0x6D0, symBinAddr: 0x2610, symSize: 0x10 }
-  - { offsetInCU: 0x768, offset: 0x79901, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14flush2DContextyys5Int64VFZTo', symObjAddr: 0x6F0, symBinAddr: 0x2630, symSize: 0x10 }
-  - { offsetInCU: 0x7BF, offset: 0x79958, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC7flushGLySbs5Int64VFZTo', symObjAddr: 0x710, symBinAddr: 0x2650, symSize: 0x10 }
-  - { offsetInCU: 0x816, offset: 0x799AF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9releaseGLyys5Int64VFZTo', symObjAddr: 0x730, symBinAddr: 0x2670, symSize: 0x10 }
-  - { offsetInCU: 0x86D, offset: 0x79A06, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC12getGLPointerys5Int64VAFFZTo', symObjAddr: 0x750, symBinAddr: 0x2690, symSize: 0x10 }
-  - { offsetInCU: 0x8C4, offset: 0x79A5D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC16releaseGLPointeryys5Int64VFZTo', symObjAddr: 0x770, symBinAddr: 0x26B0, symSize: 0x10 }
-  - { offsetInCU: 0x943, offset: 0x79ADC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15create2DContextys5Int64VAF_s5Int32VAHSbSfA2HSfAHtFZTo', symObjAddr: 0x790, symBinAddr: 0x26D0, symSize: 0x40 }
-  - { offsetInCU: 0x9EE, offset: 0x79B87, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23updateGLSurfaceWithViewyys5Int64V_s5Int32VAhFtFZTo', symObjAddr: 0x7E0, symBinAddr: 0x2720, symSize: 0x20 }
-  - { offsetInCU: 0xA61, offset: 0x79BFA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC6test2Dyys5Int64VFZTo', symObjAddr: 0x810, symBinAddr: 0x2750, symSize: 0x10 }
-  - { offsetInCU: 0xAB8, offset: 0x79C51, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13testToDataURLySSs5Int64VFZTo', symObjAddr: 0x880, symBinAddr: 0x27C0, symSize: 0x70 }
-  - { offsetInCU: 0xB43, offset: 0x79CDC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZTo', symObjAddr: 0xA90, symBinAddr: 0x29D0, symSize: 0xA0 }
-  - { offsetInCU: 0xB94, offset: 0x79D2D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZTo', symObjAddr: 0xD90, symBinAddr: 0x2CD0, symSize: 0xA0 }
-  - { offsetInCU: 0xBE5, offset: 0x79D7E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZTo', symObjAddr: 0x10F0, symBinAddr: 0x3030, symSize: 0xA0 }
-  - { offsetInCU: 0xC41, offset: 0x79DDA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZTo', symObjAddr: 0x1540, symBinAddr: 0x3480, symSize: 0xD0 }
-  - { offsetInCU: 0xC89, offset: 0x79E22, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC32getPixelsPerInchForCurrentDeviceSSyFZTo', symObjAddr: 0x1620, symBinAddr: 0x3560, symSize: 0x40 }
-  - { offsetInCU: 0xCE9, offset: 0x79E82, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCACycfcTo', symObjAddr: 0x16B0, symBinAddr: 0x35F0, symSize: 0x30 }
-  - { offsetInCU: 0xD3C, offset: 0x79ED5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC19getBytesFromUIImageySo13NSMutableDataCSo0G0CFZTf4nd_n', symObjAddr: 0x1720, symBinAddr: 0x3660, symSize: 0x300 }
-  - { offsetInCU: 0xF6C, offset: 0x7A105, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13createPatternys5Int64VAF_So7UIImageCSStFZTf4nnnd_n', symObjAddr: 0x1A20, symBinAddr: 0x3960, symSize: 0x260 }
-  - { offsetInCU: 0x1166, offset: 0x7A2FF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC25loadImageAssetWithContextySbs5Int64V_So7UIImageCtFZTf4nnd_n', symObjAddr: 0x1C80, symBinAddr: 0x3BC0, symSize: 0xD0 }
-  - { offsetInCU: 0x1263, offset: 0x7A3FC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dyys5Int64V_So7UIImageCS2ftFZTf4nnnnd_n', symObjAddr: 0x1D50, symBinAddr: 0x3C90, symSize: 0x1B0 }
-  - { offsetInCU: 0x13D8, offset: 0x7A571, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dy2dw2dhys5Int64V_So7UIImageCS4ftFZTf4nnnnnnd_n', symObjAddr: 0x1F00, symBinAddr: 0x3E40, symSize: 0x1D0 }
-  - { offsetInCU: 0x156D, offset: 0x7A706, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2sx2sy2sw2sh2dx2dy2dw2dhys5Int64V_So7UIImageCS8ftFZTf4nnnnnnnnnnd_n', symObjAddr: 0x20D0, symBinAddr: 0x4010, symSize: 0x200 }
-  - { offsetInCU: 0x1759, offset: 0x7A8F2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZTf4nnnd_n', symObjAddr: 0x22D0, symBinAddr: 0x4210, symSize: 0x1D0 }
-  - { offsetInCU: 0x1823, offset: 0x7A9BC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZTf4nnnnd_n', symObjAddr: 0x2660, symBinAddr: 0x45A0, symSize: 0x200 }
-  - { offsetInCU: 0x1904, offset: 0x7AA9D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC32getPixelsPerInchForCurrentDeviceSSyFZTf4d_n', symObjAddr: 0x2860, symBinAddr: 0x47A0, symSize: 0x110 }
-  - { offsetInCU: 0x19AF, offset: 0x7AB48, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgACIeyByy_SSSgADIeggg_TR', symObjAddr: 0xB30, symBinAddr: 0x2A70, symSize: 0x70 }
-  - { offsetInCU: 0x19C7, offset: 0x7AB60, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgSo6NSDataCSgIeyByy_SSSgAFIeggg_TR', symObjAddr: 0xE30, symBinAddr: 0x2D70, symSize: 0x50 }
-  - { offsetInCU: 0x1A34, offset: 0x7ABCD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCfETo', symObjAddr: 0x1710, symBinAddr: 0x3650, symSize: 0x10 }
-  - { offsetInCU: 0x1ABF, offset: 0x7AC58, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCMa', symObjAddr: 0x2970, symBinAddr: 0x48B0, symSize: 0x20 }
-  - { offsetInCU: 0x1AD3, offset: 0x7AC6C, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgACIeyByy_SSSgADIeggg_TRTA', symObjAddr: 0x29B0, symBinAddr: 0x48F0, symSize: 0x10 }
-  - { offsetInCU: 0x1AF2, offset: 0x7AC8B, size: 0x8, addend: 0x0, symName: '_$sSo7NSErrorCSg10ObjectiveC8ObjCBoolVIeyByy_ACSbIeggy_TRTA', symObjAddr: 0x29C0, symBinAddr: 0x4900, symSize: 0x20 }
-  - { offsetInCU: 0x1B1B, offset: 0x7ACB4, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgSo6NSDataCSgIeyByy_SSSgAFIeggg_TRTA', symObjAddr: 0x29E0, symBinAddr: 0x4920, symSize: 0x10 }
-  - { offsetInCU: 0x1B2F, offset: 0x7ACC8, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCMa', symObjAddr: 0x29F0, symBinAddr: 0x4930, symSize: 0x30 }
-  - { offsetInCU: 0x1B43, offset: 0x7ACDC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZyyYbcfU_TA', symObjAddr: 0x2A70, symBinAddr: 0x49B0, symSize: 0x40 }
-  - { offsetInCU: 0x1B57, offset: 0x7ACF0, size: 0x8, addend: 0x0, symName: _block_copy_helper, symObjAddr: 0x2AB0, symBinAddr: 0x49F0, symSize: 0x20 }
-  - { offsetInCU: 0x1B6B, offset: 0x7AD04, size: 0x8, addend: 0x0, symName: _block_destroy_helper, symObjAddr: 0x2AD0, symBinAddr: 0x4A10, symSize: 0x10 }
-  - { offsetInCU: 0x1B7F, offset: 0x7AD18, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZyyYbcfU_yyYbcfU0_TA', symObjAddr: 0x2B00, symBinAddr: 0x4A40, symSize: 0x40 }
-  - { offsetInCU: 0x1BB3, offset: 0x7AD4C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZyyYbcfU_yyYbcfU0_TA', symObjAddr: 0x2BC0, symBinAddr: 0x4B00, symSize: 0x40 }
-  - { offsetInCU: 0x1BF1, offset: 0x7AD8A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZyyYbcfU_yyYbcfU_TA', symObjAddr: 0x2C00, symBinAddr: 0x4B40, symSize: 0x20 }
-  - { offsetInCU: 0x1C25, offset: 0x7ADBE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZyyYbcfU_yyYbcfU_TA', symObjAddr: 0x2CB0, symBinAddr: 0x4BF0, symSize: 0x40 }
-  - { offsetInCU: 0x1C59, offset: 0x7ADF2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZyyYbcfU_yyYbcfU0_TA', symObjAddr: 0x2D20, symBinAddr: 0x4C60, symSize: 0x30 }
-  - { offsetInCU: 0x1C95, offset: 0x7AE2E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZyyYbcfU_TA', symObjAddr: 0x2DA0, symBinAddr: 0x4CE0, symSize: 0x30 }
-  - { offsetInCU: 0x1CA9, offset: 0x7AE42, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZyyYbcfU_yyYbcfU_TA', symObjAddr: 0x2DD0, symBinAddr: 0x4D10, symSize: 0x40 }
-  - { offsetInCU: 0x2176, offset: 0x7B30F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC19getBytesFromUIImageySo13NSMutableDataCSo0G0CFZ', symObjAddr: 0x0, symBinAddr: 0x1F40, symSize: 0x10 }
-  - { offsetInCU: 0x2191, offset: 0x7B32A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x50, symBinAddr: 0x1F90, symSize: 0x10 }
-  - { offsetInCU: 0x21AC, offset: 0x7B345, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC25loadImageAssetWithContextySbs5Int64V_So7UIImageCtFZ', symObjAddr: 0xC0, symBinAddr: 0x2000, symSize: 0x10 }
-  - { offsetInCU: 0x21CD, offset: 0x7B366, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dyys5Int64V_So7UIImageCS2ftFZ', symObjAddr: 0x110, symBinAddr: 0x2050, symSize: 0x10 }
-  - { offsetInCU: 0x21E8, offset: 0x7B381, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dy2dw2dhys5Int64V_So7UIImageCS4ftFZ', symObjAddr: 0x170, symBinAddr: 0x20B0, symSize: 0x10 }
-  - { offsetInCU: 0x2203, offset: 0x7B39C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2sx2sy2sw2sh2dx2dy2dw2dhys5Int64V_So7UIImageCS8ftFZ', symObjAddr: 0x1E0, symBinAddr: 0x2120, symSize: 0x10 }
-  - { offsetInCU: 0x221E, offset: 0x7B3B7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23initWebGPUWithViewLayerys5Int64VAF_AFs6UInt32VAHtFZ', symObjAddr: 0x280, symBinAddr: 0x21C0, symSize: 0x10 }
-  - { offsetInCU: 0x22AC, offset: 0x7B445, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC18initWebGPUWithViewys5Int64VAF_AFs6UInt32VAHtFZ', symObjAddr: 0x2B0, symBinAddr: 0x21F0, symSize: 0x10 }
-  - { offsetInCU: 0x232B, offset: 0x7B4C4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14initGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbtFZ', symObjAddr: 0x2E0, symBinAddr: 0x2220, symSize: 0x70 }
-  - { offsetInCU: 0x247D, offset: 0x7B616, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC20initSharedGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbAFtFZ', symObjAddr: 0x3D0, symBinAddr: 0x2310, symSize: 0x70 }
-  - { offsetInCU: 0x25DB, offset: 0x7B774, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC24initGLWithWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbtFZ', symObjAddr: 0x4C0, symBinAddr: 0x2400, symSize: 0x70 }
-  - { offsetInCU: 0x2739, offset: 0x7B8D2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC26initSharedGLWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbAFtFZ', symObjAddr: 0x5B0, symBinAddr: 0x24F0, symSize: 0x80 }
-  - { offsetInCU: 0x28AD, offset: 0x7BA46, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15resize2DContextyys5Int64V_S2ftFZ', symObjAddr: 0x6C0, symBinAddr: 0x2600, symSize: 0x10 }
-  - { offsetInCU: 0x291D, offset: 0x7BAB6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14flush2DContextyys5Int64VFZ', symObjAddr: 0x6E0, symBinAddr: 0x2620, symSize: 0x10 }
-  - { offsetInCU: 0x2960, offset: 0x7BAF9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC7flushGLySbs5Int64VFZ', symObjAddr: 0x700, symBinAddr: 0x2640, symSize: 0x10 }
-  - { offsetInCU: 0x29A5, offset: 0x7BB3E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9releaseGLyys5Int64VFZ', symObjAddr: 0x720, symBinAddr: 0x2660, symSize: 0x10 }
-  - { offsetInCU: 0x29E8, offset: 0x7BB81, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC12getGLPointerys5Int64VAFFZ', symObjAddr: 0x740, symBinAddr: 0x2680, symSize: 0x10 }
-  - { offsetInCU: 0x2A2B, offset: 0x7BBC4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC16releaseGLPointeryys5Int64VFZ', symObjAddr: 0x760, symBinAddr: 0x26A0, symSize: 0x10 }
-  - { offsetInCU: 0x2A6E, offset: 0x7BC07, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15create2DContextys5Int64VAF_s5Int32VAHSbSfA2HSfAHtFZ', symObjAddr: 0x780, symBinAddr: 0x26C0, symSize: 0x10 }
-  - { offsetInCU: 0x2B54, offset: 0x7BCED, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23updateGLSurfaceWithViewyys5Int64V_s5Int32VAhFtFZ', symObjAddr: 0x7D0, symBinAddr: 0x2710, symSize: 0x10 }
-  - { offsetInCU: 0x2BD3, offset: 0x7BD6C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC6test2Dyys5Int64VFZ', symObjAddr: 0x800, symBinAddr: 0x2740, symSize: 0x10 }
-  - { offsetInCU: 0x2C16, offset: 0x7BDAF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13testToDataURLySSs5Int64VFZ', symObjAddr: 0x820, symBinAddr: 0x2760, symSize: 0x60 }
-  - { offsetInCU: 0x2CD7, offset: 0x7BE70, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZ', symObjAddr: 0x8F0, symBinAddr: 0x2830, symSize: 0x10 }
-  - { offsetInCU: 0x2CEB, offset: 0x7BE84, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZyyYbcfU_', symObjAddr: 0x900, symBinAddr: 0x2840, symSize: 0x190 }
-  - { offsetInCU: 0x2D8B, offset: 0x7BF24, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZ', symObjAddr: 0xBA0, symBinAddr: 0x2AE0, symSize: 0x30 }
-  - { offsetInCU: 0x2D9F, offset: 0x7BF38, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZyyYbcfU_', symObjAddr: 0xBD0, symBinAddr: 0x2B10, symSize: 0x1C0 }
-  - { offsetInCU: 0x2E89, offset: 0x7C022, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZ', symObjAddr: 0xE80, symBinAddr: 0x2DC0, symSize: 0x30 }
-  - { offsetInCU: 0x2E9D, offset: 0x7C036, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZyyYbcfU_', symObjAddr: 0xEB0, symBinAddr: 0x2DF0, symSize: 0x240 }
-  - { offsetInCU: 0x2F51, offset: 0x7C0EA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZ', symObjAddr: 0x1190, symBinAddr: 0x30D0, symSize: 0x10 }
-  - { offsetInCU: 0x2F65, offset: 0x7C0FE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZyyYbcfU_', symObjAddr: 0x11A0, symBinAddr: 0x30E0, symSize: 0x3A0 }
-  - { offsetInCU: 0x31FB, offset: 0x7C394, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC32getPixelsPerInchForCurrentDeviceSSyFZ', symObjAddr: 0x1610, symBinAddr: 0x3550, symSize: 0x10 }
-  - { offsetInCU: 0x3216, offset: 0x7C3AF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCACycfC', symObjAddr: 0x1660, symBinAddr: 0x35A0, symSize: 0x20 }
-  - { offsetInCU: 0x322A, offset: 0x7C3C3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCACycfc', symObjAddr: 0x1680, symBinAddr: 0x35C0, symSize: 0x30 }
-  - { offsetInCU: 0x3260, offset: 0x7C3F9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCfD', symObjAddr: 0x16E0, symBinAddr: 0x3620, symSize: 0x30 }
-  - { offsetInCU: 0x4F, offset: 0x7C631, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19shared_context_view33_508084857CA7D194CA72FEB80DD78002LLSo7GLKViewCvpZ', symObjAddr: 0x5C38, symBinAddr: 0x12D2EA0, symSize: 0x0 }
-  - { offsetInCU: 0x69, offset: 0x7C64B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15_shared_context33_508084857CA7D194CA72FEB80DD78002LLs5Int64VvpZ', symObjAddr: 0x5C40, symBinAddr: 0x12D2EA8, symSize: 0x0 }
-  - { offsetInCU: 0x83, offset: 0x7C665, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5storeSo19NSMutableDictionaryCvpZ', symObjAddr: 0x5C48, symBinAddr: 0x12D2EB0, symSize: 0x0 }
-  - { offsetInCU: 0x9D, offset: 0x7C67F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5views33_508084857CA7D194CA72FEB80DD78002LLSo10NSMapTableCySo8NSStringCACGvpZ', symObjAddr: 0x5C50, symBinAddr: 0x12D2EB8, symSize: 0x0 }
-  - { offsetInCU: 0xAB, offset: 0x7C68D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19shared_context_view33_508084857CA7D194CA72FEB80DD78002LL_WZ', symObjAddr: 0x0, symBinAddr: 0x4FE0, symSize: 0x60 }
-  - { offsetInCU: 0xF0, offset: 0x7C6D2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5store_WZ', symObjAddr: 0x60, symBinAddr: 0x5040, symSize: 0x30 }
-  - { offsetInCU: 0x135, offset: 0x7C717, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5views33_508084857CA7D194CA72FEB80DD78002LL_WZ', symObjAddr: 0xD0, symBinAddr: 0x50B0, symSize: 0x40 }
-  - { offsetInCU: 0x187, offset: 0x7C769, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC3ptrSvSgvgTo', symObjAddr: 0x1B0, symBinAddr: 0x5190, symSize: 0x20 }
-  - { offsetInCU: 0x1DD, offset: 0x7C7BF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC3ptrSvSgvsTo', symObjAddr: 0x1D0, symBinAddr: 0x51B0, symSize: 0x20 }
-  - { offsetInCU: 0x236, offset: 0x7C818, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6mtlPtrSvSgvgTo', symObjAddr: 0x1F0, symBinAddr: 0x51D0, symSize: 0x20 }
-  - { offsetInCU: 0x28C, offset: 0x7C86E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6mtlPtrSvSgvsTo', symObjAddr: 0x210, symBinAddr: 0x51F0, symSize: 0x20 }
-  - { offsetInCU: 0x2E5, offset: 0x7C8C7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvgTo', symObjAddr: 0x320, symBinAddr: 0x5300, symSize: 0x40 }
-  - { offsetInCU: 0x320, offset: 0x7C902, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvsTo', symObjAddr: 0x390, symBinAddr: 0x5370, symSize: 0x30 }
-  - { offsetInCU: 0x3AF, offset: 0x7C991, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8nativeGLs5Int64VvgTo', symObjAddr: 0x5D0, symBinAddr: 0x55B0, symSize: 0x40 }
-  - { offsetInCU: 0x405, offset: 0x7C9E7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8nativeGLs5Int64VvsTo', symObjAddr: 0x640, symBinAddr: 0x5620, symSize: 0x40 }
-  - { offsetInCU: 0x45E, offset: 0x7CA40, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13nativeContexts5Int64VvgTo', symObjAddr: 0x680, symBinAddr: 0x5660, symSize: 0x40 }
-  - { offsetInCU: 0x4B4, offset: 0x7CA96, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13nativeContexts5Int64VvsTo', symObjAddr: 0x6F0, symBinAddr: 0x56D0, symSize: 0x40 }
-  - { offsetInCU: 0x50D, offset: 0x7CAEF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15native2DContexts5Int64VvgTo', symObjAddr: 0x730, symBinAddr: 0x5710, symSize: 0x20 }
-  - { offsetInCU: 0x563, offset: 0x7CB45, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15native2DContexts5Int64VvsTo', symObjAddr: 0x750, symBinAddr: 0x5730, symSize: 0x20 }
-  - { offsetInCU: 0x5BC, offset: 0x7CB9E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7mtlViewSo7MTKViewCvgTo', symObjAddr: 0x770, symBinAddr: 0x5750, symSize: 0x20 }
-  - { offsetInCU: 0x614, offset: 0x7CBF6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7mtlViewSo7MTKViewCvsTo', symObjAddr: 0x790, symBinAddr: 0x5770, symSize: 0x30 }
-  - { offsetInCU: 0x66D, offset: 0x7CC4F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7glkViewAA0A7GLKViewCvgTo', symObjAddr: 0x7C0, symBinAddr: 0x57A0, symSize: 0x20 }
-  - { offsetInCU: 0x6C5, offset: 0x7CCA7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7glkViewAA0A7GLKViewCvsTo', symObjAddr: 0x7E0, symBinAddr: 0x57C0, symSize: 0x30 }
-  - { offsetInCU: 0x71E, offset: 0x7CD00, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC4is2DSbvgTo', symObjAddr: 0x810, symBinAddr: 0x57F0, symSize: 0x20 }
-  - { offsetInCU: 0x774, offset: 0x7CD56, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC4is2DSbvsTo', symObjAddr: 0x830, symBinAddr: 0x5810, symSize: 0x10 }
-  - { offsetInCU: 0x7CD, offset: 0x7CDAF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7isMetalSbvgTo', symObjAddr: 0x840, symBinAddr: 0x5820, symSize: 0x20 }
-  - { offsetInCU: 0x823, offset: 0x7CE05, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7isMetalSbvsTo', symObjAddr: 0x860, symBinAddr: 0x5840, symSize: 0x10 }
-  - { offsetInCU: 0x866, offset: 0x7CE48, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18drawingBufferWidthSivgTo', symObjAddr: 0x870, symBinAddr: 0x5850, symSize: 0x30 }
-  - { offsetInCU: 0x898, offset: 0x7CE7A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19drawingBufferHeightSivgTo', symObjAddr: 0x960, symBinAddr: 0x5940, symSize: 0x30 }
-  - { offsetInCU: 0x8E0, offset: 0x7CEC2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5widthSfvgTo', symObjAddr: 0xA50, symBinAddr: 0x5A30, symSize: 0x30 }
-  - { offsetInCU: 0x948, offset: 0x7CF2A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6heightSfvgTo', symObjAddr: 0xAB0, symBinAddr: 0x5A90, symSize: 0x30 }
-  - { offsetInCU: 0x9E7, offset: 0x7CFC9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11initContextyySS_S4bs5Int32VS5btFTo', symObjAddr: 0xB20, symBinAddr: 0x5B00, symSize: 0xD0 }
-  - { offsetInCU: 0xA96, offset: 0x7D078, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17initWebGPUContextyys5Int64VFTo', symObjAddr: 0xDA0, symBinAddr: 0x5D80, symSize: 0x30 }
-  - { offsetInCU: 0xB46, offset: 0x7D128, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC015initContextWithE10AttributesyySS_S4bs5Int32VS5btFTo', symObjAddr: 0x1760, symBinAddr: 0x6740, symSize: 0xD0 }
-  - { offsetInCU: 0xBB0, offset: 0x7D192, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15create2DContextys5Int64VSb_S3bs5Int32VS5bAHtFTo', symObjAddr: 0x1A70, symBinAddr: 0x6A50, symSize: 0x90 }
-  - { offsetInCU: 0xBED, offset: 0x7D1CF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11forceLayoutyy12CoreGraphics7CGFloatV_AGtFTo', symObjAddr: 0x1BF0, symBinAddr: 0x6BD0, symSize: 0x100 }
-  - { offsetInCU: 0xC6B, offset: 0x7D24D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8snapshotySo7UIImageCSgSbFTo', symObjAddr: 0x1DC0, symBinAddr: 0x6DA0, symSize: 0x40 }
-  - { offsetInCU: 0xC9E, offset: 0x7D280, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8rendererAA9NSCRenderCSgvgTo', symObjAddr: 0x1E00, symBinAddr: 0x6DE0, symSize: 0x20 }
-  - { offsetInCU: 0xCF8, offset: 0x7D2DA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8rendererAA9NSCRenderCSgvsTo', symObjAddr: 0x1E20, symBinAddr: 0x6E00, symSize: 0x30 }
-  - { offsetInCU: 0xD53, offset: 0x7D335, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6renderSbyFTo', symObjAddr: 0x1E90, symBinAddr: 0x6E70, symSize: 0x40 }
-  - { offsetInCU: 0xDE9, offset: 0x7D3CB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13context2DTestyys5Int64VFTo', symObjAddr: 0x1F10, symBinAddr: 0x6EF0, symSize: 0x60 }
-  - { offsetInCU: 0xEAE, offset: 0x7D490, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC22context2DTestToDataURLySSs5Int64VFTo', symObjAddr: 0x1FD0, symBinAddr: 0x6FB0, symSize: 0xA0 }
-  - { offsetInCU: 0xF3B, offset: 0x7D51D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC23enterBackgroundListeneryycSgvsTo', symObjAddr: 0x20C0, symBinAddr: 0x70A0, symSize: 0x70 }
-  - { offsetInCU: 0xF9D, offset: 0x7D57F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC20becomeActiveListeneryycSgvsTo', symObjAddr: 0x21D0, symBinAddr: 0x71B0, symSize: 0x70 }
-  - { offsetInCU: 0xFFA, offset: 0x7D5DC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvgTo', symObjAddr: 0x2240, symBinAddr: 0x7220, symSize: 0xB0 }
-  - { offsetInCU: 0x104A, offset: 0x7D62C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvsTo', symObjAddr: 0x23B0, symBinAddr: 0x7390, symSize: 0x90 }
-  - { offsetInCU: 0x10DA, offset: 0x7D6BC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5coderACSgSo7NSCoderC_tcfcTo', symObjAddr: 0x3160, symBinAddr: 0x8140, symSize: 0x30 }
-  - { offsetInCU: 0x112F, offset: 0x7D711, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5frameACSo6CGRectV_tcfcTo', symObjAddr: 0x3D20, symBinAddr: 0x8D00, symSize: 0x30 }
-  - { offsetInCU: 0x1162, offset: 0x7D744, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvgTo', symObjAddr: 0x3D50, symBinAddr: 0x8D30, symSize: 0x20 }
-  - { offsetInCU: 0x11BA, offset: 0x7D79C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvsTo', symObjAddr: 0x3D70, symBinAddr: 0x8D50, symSize: 0x30 }
-  - { offsetInCU: 0x1228, offset: 0x7D80A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13readyListenerAA0cE0_pSgvgTo', symObjAddr: 0x3E20, symBinAddr: 0x8E00, symSize: 0x30 }
-  - { offsetInCU: 0x1282, offset: 0x7D864, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13readyListenerAA0cE0_pSgvsTo', symObjAddr: 0x3E50, symBinAddr: 0x8E30, symSize: 0x30 }
-  - { offsetInCU: 0x12E2, offset: 0x7D8C4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11setListeneryyAA0cE0_pSgFTo', symObjAddr: 0x3EB0, symBinAddr: 0x8E90, symSize: 0x30 }
-  - { offsetInCU: 0x1426, offset: 0x7DA08, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC14layoutSubviewsyyFTo', symObjAddr: 0x4290, symBinAddr: 0x9270, symSize: 0x30 }
-  - { offsetInCU: 0x1459, offset: 0x7DA3B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCfDTo', symObjAddr: 0x45B0, symBinAddr: 0x9590, symSize: 0x20 }
-  - { offsetInCU: 0x1494, offset: 0x7DA76, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC21getBoundingClientRectyySo6UIViewC_SvtFZTo', symObjAddr: 0x46A0, symBinAddr: 0x9680, symSize: 0x30 }
-  - { offsetInCU: 0x14C7, offset: 0x7DAA9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC14shared_context33_508084857CA7D194CA72FEB80DD78002LLs5Int64VvgZTf4d_n', symObjAddr: 0x50D0, symBinAddr: 0xA0B0, symSize: 0x2A0 }
-  - { offsetInCU: 0x162F, offset: 0x7DC11, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC21getBoundingClientRectyySo6UIViewC_SvtFZTf4nnd_n', symObjAddr: 0x5440, symBinAddr: 0xA420, symSize: 0xC0 }
-  - { offsetInCU: 0x184B, offset: 0x7DE2D, size: 0x8, addend: 0x0, symName: '_$sIeg_IeyB_TR', symObjAddr: 0x2090, symBinAddr: 0x7070, symSize: 0x30 }
-  - { offsetInCU: 0x1863, offset: 0x7DE45, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_So8NSStringCABIeyByy_TR', symObjAddr: 0x2340, symBinAddr: 0x7320, symSize: 0x70 }
-  - { offsetInCU: 0x187B, offset: 0x7DE5D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvpACTK', symObjAddr: 0x24A0, symBinAddr: 0x7480, symSize: 0x90 }
-  - { offsetInCU: 0x18B3, offset: 0x7DE95, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvpACTk', symObjAddr: 0x2530, symBinAddr: 0x7510, symSize: 0xC0 }
-  - { offsetInCU: 0x18F3, offset: 0x7DED5, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCytIegnnr_SSABIeggg_TR', symObjAddr: 0x25F0, symBinAddr: 0x75D0, symSize: 0x70 }
-  - { offsetInCU: 0x19A3, offset: 0x7DF85, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCfETo', symObjAddr: 0x45D0, symBinAddr: 0x95B0, symSize: 0xC0 }
-  - { offsetInCU: 0x19D3, offset: 0x7DFB5, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_SgWOy', symObjAddr: 0x46D0, symBinAddr: 0x96B0, symSize: 0x20 }
-  - { offsetInCU: 0x19E7, offset: 0x7DFC9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCMa', symObjAddr: 0x46F0, symBinAddr: 0x96D0, symSize: 0x20 }
-  - { offsetInCU: 0x19FB, offset: 0x7DFDD, size: 0x8, addend: 0x0, symName: '_$ss29getContiguousArrayStorageType3fors01_bcD0CyxGmxm_tlFSo18NSLayoutConstraintC_Tgm5', symObjAddr: 0x4710, symBinAddr: 0x96F0, symSize: 0x60 }
-  - { offsetInCU: 0x1C02, offset: 0x7E1E4, size: 0x8, addend: 0x0, symName: ___swift_instantiateConcreteTypeFromMangledName, symObjAddr: 0x5370, symBinAddr: 0xA350, symSize: 0x40 }
-  - { offsetInCU: 0x1C16, offset: 0x7E1F8, size: 0x8, addend: 0x0, symName: '_$sypSgWOh', symObjAddr: 0x53B0, symBinAddr: 0xA390, symSize: 0x30 }
-  - { offsetInCU: 0x1C2A, offset: 0x7E20C, size: 0x8, addend: 0x0, symName: ___swift_project_boxed_opaque_existential_0, symObjAddr: 0x53E0, symBinAddr: 0xA3C0, symSize: 0x30 }
-  - { offsetInCU: 0x1C3E, offset: 0x7E220, size: 0x8, addend: 0x0, symName: ___swift_destroy_boxed_opaque_existential_0, symObjAddr: 0x5410, symBinAddr: 0xA3F0, symSize: 0x30 }
-  - { offsetInCU: 0x1C5D, offset: 0x7E23F, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSo19UIGestureRecognizerCIeyByy_SSADIeggg_TRTA', symObjAddr: 0x59A0, symBinAddr: 0xA980, symSize: 0x40 }
-  - { offsetInCU: 0x1C86, offset: 0x7E268, size: 0x8, addend: 0x0, symName: _block_copy_helper, symObjAddr: 0x59E0, symBinAddr: 0xA9C0, symSize: 0x20 }
-  - { offsetInCU: 0x1C9A, offset: 0x7E27C, size: 0x8, addend: 0x0, symName: _block_destroy_helper, symObjAddr: 0x5A00, symBinAddr: 0xA9E0, symSize: 0x10 }
-  - { offsetInCU: 0x1CAE, offset: 0x7E290, size: 0x8, addend: 0x0, symName: '_$sIeg_SgWOe', symObjAddr: 0x5A10, symBinAddr: 0xA9F0, symSize: 0x20 }
-  - { offsetInCU: 0x1CCD, offset: 0x7E2AF, size: 0x8, addend: 0x0, symName: '_$sIeyB_Ieg_TRTA', symObjAddr: 0x5A30, symBinAddr: 0xAA10, symSize: 0x10 }
-  - { offsetInCU: 0x1CF6, offset: 0x7E2D8, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCytIegnnr_SSABIeggg_TRTA', symObjAddr: 0x5A60, symBinAddr: 0xAA40, symSize: 0x20 }
-  - { offsetInCU: 0x1D15, offset: 0x7E2F7, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_SSABytIegnnr_TRTA', symObjAddr: 0x5A80, symBinAddr: 0xAA60, symSize: 0x30 }
-  - { offsetInCU: 0x1D3E, offset: 0x7E320, size: 0x8, addend: 0x0, symName: '_$sypWOb', symObjAddr: 0x5AB0, symBinAddr: 0xAA90, symSize: 0x20 }
-  - { offsetInCU: 0x1D52, offset: 0x7E334, size: 0x8, addend: 0x0, symName: '_$sypWOc', symObjAddr: 0x5B00, symBinAddr: 0xAAE0, symSize: 0x30 }
-  - { offsetInCU: 0x1FD7, offset: 0x7E5B9, size: 0x8, addend: 0x0, symName: '_$sSD17dictionaryLiteralSDyxq_Gx_q_td_tcfCSS_ypTgm5Tf4g_n', symObjAddr: 0x4FE0, symBinAddr: 0x9FC0, symSize: 0xF0 }
-  - { offsetInCU: 0x2469, offset: 0x7EA4B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvg', symObjAddr: 0x360, symBinAddr: 0x5340, symSize: 0x30 }
-  - { offsetInCU: 0x249A, offset: 0x7EA7C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvs', symObjAddr: 0x3C0, symBinAddr: 0x53A0, symSize: 0xE0 }
-  - { offsetInCU: 0x24E4, offset: 0x7EAC6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvM', symObjAddr: 0x4A0, symBinAddr: 0x5480, symSize: 0x50 }
-  - { offsetInCU: 0x2507, offset: 0x7EAE9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvM.resume.0', symObjAddr: 0x4F0, symBinAddr: 0x54D0, symSize: 0xE0 }
-  - { offsetInCU: 0x2548, offset: 0x7EB2A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8nativeGLs5Int64Vvg', symObjAddr: 0x610, symBinAddr: 0x55F0, symSize: 0x30 }
-  - { offsetInCU: 0x259E, offset: 0x7EB80, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13nativeContexts5Int64Vvg', symObjAddr: 0x6C0, symBinAddr: 0x56A0, symSize: 0x30 }
-  - { offsetInCU: 0x270A, offset: 0x7ECEC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18drawingBufferWidthSivg', symObjAddr: 0x8A0, symBinAddr: 0x5880, symSize: 0xC0 }
-  - { offsetInCU: 0x282F, offset: 0x7EE11, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19drawingBufferHeightSivg', symObjAddr: 0x990, symBinAddr: 0x5970, symSize: 0xC0 }
-  - { offsetInCU: 0x2975, offset: 0x7EF57, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5widthSfvg', symObjAddr: 0xA80, symBinAddr: 0x5A60, symSize: 0x30 }
-  - { offsetInCU: 0x29BB, offset: 0x7EF9D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6heightSfvg', symObjAddr: 0xAE0, symBinAddr: 0x5AC0, symSize: 0x30 }
-  - { offsetInCU: 0x29ED, offset: 0x7EFCF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11initContextyySS_S4bs5Int32VS5btF', symObjAddr: 0xB10, symBinAddr: 0x5AF0, symSize: 0x10 }
-  - { offsetInCU: 0x2B6A, offset: 0x7F14C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17initWebGPUContextyys5Int64VF', symObjAddr: 0xBF0, symBinAddr: 0x5BD0, symSize: 0x1B0 }
-  - { offsetInCU: 0x2F4D, offset: 0x7F52F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC015initContextWithE10AttributesyySS_S4bs5Int32VS5btF', symObjAddr: 0xDD0, symBinAddr: 0x5DB0, symSize: 0x990 }
-  - { offsetInCU: 0x36DB, offset: 0x7FCBD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15create2DContextys5Int64VSb_S3bs5Int32VS5bAHtF', symObjAddr: 0x1830, symBinAddr: 0x6810, symSize: 0x240 }
-  - { offsetInCU: 0x3B67, offset: 0x80149, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11forceLayoutyy12CoreGraphics7CGFloatV_AGtF', symObjAddr: 0x1B00, symBinAddr: 0x6AE0, symSize: 0xF0 }
-  - { offsetInCU: 0x3BF6, offset: 0x801D8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8snapshotySo7UIImageCSgSbF', symObjAddr: 0x1CF0, symBinAddr: 0x6CD0, symSize: 0xD0 }
-  - { offsetInCU: 0x3D4F, offset: 0x80331, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6renderSbyF', symObjAddr: 0x1E50, symBinAddr: 0x6E30, symSize: 0x40 }
-  - { offsetInCU: 0x3DD3, offset: 0x803B5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13context2DTestyys5Int64VF', symObjAddr: 0x1ED0, symBinAddr: 0x6EB0, symSize: 0x40 }
-  - { offsetInCU: 0x3EF2, offset: 0x804D4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC22context2DTestToDataURLySSs5Int64VF', symObjAddr: 0x1F70, symBinAddr: 0x6F50, symSize: 0x60 }
-  - { offsetInCU: 0x3FE8, offset: 0x805CA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvg', symObjAddr: 0x22F0, symBinAddr: 0x72D0, symSize: 0x50 }
-  - { offsetInCU: 0x4032, offset: 0x80614, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvs', symObjAddr: 0x2440, symBinAddr: 0x7420, symSize: 0x60 }
-  - { offsetInCU: 0x4059, offset: 0x8063B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvM', symObjAddr: 0x2660, symBinAddr: 0x7640, symSize: 0x40 }
-  - { offsetInCU: 0x407F, offset: 0x80661, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvM.resume.0', symObjAddr: 0x26A0, symBinAddr: 0x7680, symSize: 0x10 }
-  - { offsetInCU: 0x4141, offset: 0x80723, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5coderACSgSo7NSCoderC_tcfc', symObjAddr: 0x26B0, symBinAddr: 0x7690, symSize: 0xAB0 }
-  - { offsetInCU: 0x4366, offset: 0x80948, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5frameACSo6CGRectV_tcfC', symObjAddr: 0x3190, symBinAddr: 0x8170, symSize: 0x80 }
-  - { offsetInCU: 0x438F, offset: 0x80971, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5frameACSo6CGRectV_tcfc', symObjAddr: 0x3210, symBinAddr: 0x81F0, symSize: 0xB10 }
-  - { offsetInCU: 0x45D5, offset: 0x80BB7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvW', symObjAddr: 0x3DA0, symBinAddr: 0x8D80, symSize: 0x80 }
-  - { offsetInCU: 0x46CB, offset: 0x80CAD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11setListeneryyAA0cE0_pSgF', symObjAddr: 0x3E80, symBinAddr: 0x8E60, symSize: 0x30 }
-  - { offsetInCU: 0x4767, offset: 0x80D49, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6resize33_508084857CA7D194CA72FEB80DD78002LLyyF', symObjAddr: 0x3EE0, symBinAddr: 0x8EC0, symSize: 0x110 }
-  - { offsetInCU: 0x49B8, offset: 0x80F9A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC14layoutSubviewsyyF', symObjAddr: 0x3FF0, symBinAddr: 0x8FD0, symSize: 0x2A0 }
-  - { offsetInCU: 0x4C14, offset: 0x811F6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCfD', symObjAddr: 0x42C0, symBinAddr: 0x92A0, symSize: 0x2F0 }
-  - { offsetInCU: 0x4CA2, offset: 0x81284, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC21getBoundingClientRectyySo6UIViewC_SvtFZ', symObjAddr: 0x4690, symBinAddr: 0x9670, symSize: 0x10 }
-  - { offsetInCU: 0x4CCA, offset: 0x812AC, size: 0x8, addend: 0x0, symName: '_$ss22__RawDictionaryStorageC4findys10_HashTableV6BucketV6bucket_Sb5foundtxSHRzlFSS_Tg5', symObjAddr: 0x4770, symBinAddr: 0x9750, symSize: 0x60 }
-  - { offsetInCU: 0x4D24, offset: 0x81306, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV7_insert2at3key5valueys10_HashTableV6BucketV_xnq_ntFSS_ypTg5', symObjAddr: 0x47D0, symBinAddr: 0x97B0, symSize: 0x60 }
-  - { offsetInCU: 0x4D90, offset: 0x81372, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV12mutatingFind_8isUniques10_HashTableV6BucketV6bucket_Sb5foundtx_SbtFSS_ypTg5', symObjAddr: 0x4830, symBinAddr: 0x9810, symSize: 0xB0 }
-  - { offsetInCU: 0x4DCD, offset: 0x813AF, size: 0x8, addend: 0x0, symName: '_$ss22__RawDictionaryStorageC4find_9hashValues10_HashTableV6BucketV6bucket_Sb5foundtx_SitSHRzlFSS_Tg5', symObjAddr: 0x48E0, symBinAddr: 0x98C0, symSize: 0xE0 }
-  - { offsetInCU: 0x4E38, offset: 0x8141A, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV4copyyyFSS_ypTg5', symObjAddr: 0x49C0, symBinAddr: 0x99A0, symSize: 0x260 }
-  - { offsetInCU: 0x4EE0, offset: 0x814C2, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV20_copyOrMoveAndResize8capacity12moveElementsySi_SbtFSS_ypTg5', symObjAddr: 0x4C20, symBinAddr: 0x9C00, symSize: 0x3C0 }
-  - { offsetInCU: 0x27, offset: 0x81716, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative7GLUtilsCfD', symObjAddr: 0x0, symBinAddr: 0xABC0, symSize: 0x20 }
-  - { offsetInCU: 0x62, offset: 0x81751, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative7GLUtilsCMa', symObjAddr: 0x20, symBinAddr: 0xABE0, symSize: 0x14 }
-  - { offsetInCU: 0x1AF, offset: 0x8189E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative7GLUtilsCfD', symObjAddr: 0x0, symBinAddr: 0xABC0, symSize: 0x20 }
-  - { offsetInCU: 0x65, offset: 0x8192B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8mPrograms6UInt32VvgTo', symObjAddr: 0x0, symBinAddr: 0xAC00, symSize: 0x10 }
-  - { offsetInCU: 0xBB, offset: 0x81981, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8mPrograms6UInt32VvsTo', symObjAddr: 0x10, symBinAddr: 0xAC10, symSize: 0x10 }
-  - { offsetInCU: 0x114, offset: 0x819DA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3rbos6UInt32VvgTo', symObjAddr: 0x20, symBinAddr: 0xAC20, symSize: 0x40 }
-  - { offsetInCU: 0x16A, offset: 0x81A30, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3rbos6UInt32VvsTo', symObjAddr: 0x60, symBinAddr: 0xAC60, symSize: 0x40 }
-  - { offsetInCU: 0x1C3, offset: 0x81A89, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3fbos6UInt32VvgTo', symObjAddr: 0xA0, symBinAddr: 0xACA0, symSize: 0x40 }
-  - { offsetInCU: 0x219, offset: 0x81ADF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3fbos6UInt32VvsTo', symObjAddr: 0xE0, symBinAddr: 0xACE0, symSize: 0x40 }
-  - { offsetInCU: 0x272, offset: 0x81B38, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC5widthSivgTo', symObjAddr: 0x120, symBinAddr: 0xAD20, symSize: 0x20 }
-  - { offsetInCU: 0x2C8, offset: 0x81B8E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC5widthSivsTo', symObjAddr: 0x140, symBinAddr: 0xAD40, symSize: 0x20 }
-  - { offsetInCU: 0x321, offset: 0x81BE7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC6heightSivgTo', symObjAddr: 0x160, symBinAddr: 0xAD60, symSize: 0x20 }
-  - { offsetInCU: 0x377, offset: 0x81C3D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC6heightSivsTo', symObjAddr: 0x180, symBinAddr: 0xAD80, symSize: 0x20 }
-  - { offsetInCU: 0x3D0, offset: 0x81C96, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC2abs6UInt32VvgTo', symObjAddr: 0x1A0, symBinAddr: 0xADA0, symSize: 0x40 }
-  - { offsetInCU: 0x426, offset: 0x81CEC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC2abs6UInt32VvsTo', symObjAddr: 0x1E0, symBinAddr: 0xADE0, symSize: 0x40 }
-  - { offsetInCU: 0x47F, offset: 0x81D45, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3poss5Int32VvgTo', symObjAddr: 0x220, symBinAddr: 0xAE20, symSize: 0x10 }
-  - { offsetInCU: 0x4D5, offset: 0x81D9B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3poss5Int32VvsTo', symObjAddr: 0x230, symBinAddr: 0xAE30, symSize: 0x10 }
-  - { offsetInCU: 0x52E, offset: 0x81DF4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10samplerPoss5Int32VvgTo', symObjAddr: 0x240, symBinAddr: 0xAE40, symSize: 0x10 }
-  - { offsetInCU: 0x584, offset: 0x81E4A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10samplerPoss5Int32VvsTo', symObjAddr: 0x250, symBinAddr: 0xAE50, symSize: 0x10 }
-  - { offsetInCU: 0x5DD, offset: 0x81EA3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9vextexBufSaySfGvgTo', symObjAddr: 0x260, symBinAddr: 0xAE60, symSize: 0x40 }
-  - { offsetInCU: 0x633, offset: 0x81EF9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9vextexBufSaySfGvsTo', symObjAddr: 0x2A0, symBinAddr: 0xAEA0, symSize: 0x40 }
-  - { offsetInCU: 0x676, offset: 0x81F3C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13SIZE_OF_FLOATSivgZTo', symObjAddr: 0x2E0, symBinAddr: 0xAEE0, symSize: 0x10 }
-  - { offsetInCU: 0x692, offset: 0x81F58, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13VERTEX_SHADERSSvgZTo', symObjAddr: 0x2F0, symBinAddr: 0xAEF0, symSize: 0x30 }
-  - { offsetInCU: 0x6C4, offset: 0x81F8A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7surfaceSo9IOSurfaceCSgvgTo', symObjAddr: 0x320, symBinAddr: 0xAF20, symSize: 0x20 }
-  - { offsetInCU: 0x71C, offset: 0x81FE2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7surfaceSo9IOSurfaceCSgvsTo', symObjAddr: 0x340, symBinAddr: 0xAF40, symSize: 0x30 }
-  - { offsetInCU: 0x775, offset: 0x8203B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8pixelBufs9UnmanagedVySo11CVBufferRefaGSgvgTo', symObjAddr: 0x490, symBinAddr: 0xB090, symSize: 0x20 }
-  - { offsetInCU: 0x7CB, offset: 0x82091, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8pixelBufs9UnmanagedVySo11CVBufferRefaGSgvsTo', symObjAddr: 0x4B0, symBinAddr: 0xB0B0, symSize: 0x20 }
-  - { offsetInCU: 0x83A, offset: 0x82100, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCACycfcTo', symObjAddr: 0x680, symBinAddr: 0xB240, symSize: 0x20 }
-  - { offsetInCU: 0x86C, offset: 0x82132, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7destroyyyFTo', symObjAddr: 0x7E0, symBinAddr: 0xB3A0, symSize: 0x30 }
-  - { offsetInCU: 0x8C4, offset: 0x8218A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10texImage2Dyys5Int32V_A4fA9NSCCanvasCAHSbtFTo', symObjAddr: 0x830, symBinAddr: 0xB3F0, symSize: 0x80 }
-  - { offsetInCU: 0x928, offset: 0x821EE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9drawFrame6buffer5width6height14internalFormat6format10flipYWebGLySo11CVBufferRefa_S2is5Int32VANSbtFTo', symObjAddr: 0x8B0, symBinAddr: 0xB470, symSize: 0x80 }
-  - { offsetInCU: 0x9CA, offset: 0x82290, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13createSurfaceyyFTo', symObjAddr: 0xCE0, symBinAddr: 0xB8A0, symSize: 0x30 }
-  - { offsetInCU: 0xAB4, offset: 0x8237A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCMa', symObjAddr: 0x660, symBinAddr: 0xB220, symSize: 0x20 }
-  - { offsetInCU: 0xB33, offset: 0x823F9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCfETo', symObjAddr: 0xD40, symBinAddr: 0xB900, symSize: 0x60 }
-  - { offsetInCU: 0x1271, offset: 0x82B37, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCACycfC', symObjAddr: 0x4D0, symBinAddr: 0xB0D0, symSize: 0x20 }
-  - { offsetInCU: 0x128B, offset: 0x82B51, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCACycfc', symObjAddr: 0x4F0, symBinAddr: 0xB0F0, symSize: 0x130 }
-  - { offsetInCU: 0x12BB, offset: 0x82B81, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7destroyyyF', symObjAddr: 0x6A0, symBinAddr: 0xB260, symSize: 0x140 }
-  - { offsetInCU: 0x1474, offset: 0x82D3A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10texImage2Dyys5Int32V_A4fA9NSCCanvasCAHSbtF', symObjAddr: 0x810, symBinAddr: 0xB3D0, symSize: 0x20 }
-  - { offsetInCU: 0x1525, offset: 0x82DEB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13createSurfaceyyF', symObjAddr: 0x930, symBinAddr: 0xB4F0, symSize: 0x3B0 }
-  - { offsetInCU: 0x18BB, offset: 0x83181, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCfD', symObjAddr: 0xD10, symBinAddr: 0xB8D0, symSize: 0x30 }
-  - { offsetInCU: 0x19B4, offset: 0x8327A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10texImage2Dyys5Int32V_A4fA9NSCCanvasCAHSbtFTf4ddnndnndn_n', symObjAddr: 0xDA0, symBinAddr: 0xB960, symSize: 0x720 }
-  - { offsetInCU: 0x231C, offset: 0x83BE2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9drawFrame6buffer5width6height14internalFormat6format10flipYWebGLySo11CVBufferRefa_S2is5Int32VANSbtFTf4nnnnndn_n', symObjAddr: 0x1520, symBinAddr: 0xC0E0, symSize: 0x7EC }
-  - { offsetInCU: 0x10C, offset: 0x8478B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC6target6actionAEypSg_10ObjectiveC8SelectorVSgtcfcTo', symObjAddr: 0x1120, symBinAddr: 0xD9B0, symSize: 0x60 }
-  - { offsetInCU: 0x19C, offset: 0x8481B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerCfETo', symObjAddr: 0x11A0, symBinAddr: 0xDA30, symSize: 0x20 }
-  - { offsetInCU: 0x1CB, offset: 0x8484A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC6handleyySo19UIGestureRecognizerCFTo', symObjAddr: 0x11C0, symBinAddr: 0xDA50, symSize: 0x10 }
-  - { offsetInCU: 0x368, offset: 0x849E7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerCACycfcTo', symObjAddr: 0x1A40, symBinAddr: 0xE2D0, symSize: 0x30 }
-  - { offsetInCU: 0x5E4, offset: 0x84C63, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerCfETo', symObjAddr: 0x1AC0, symBinAddr: 0xE350, symSize: 0x60 }
-  - { offsetInCU: 0x613, offset: 0x84C92, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerCMa', symObjAddr: 0x1B20, symBinAddr: 0xE3B0, symSize: 0x20 }
-  - { offsetInCU: 0x627, offset: 0x84CA6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerCMa', symObjAddr: 0x1B40, symBinAddr: 0xE3D0, symSize: 0x20 }
-  - { offsetInCU: 0x63B, offset: 0x84CBA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwCP', symObjAddr: 0x1B60, symBinAddr: 0xE3F0, symSize: 0x30 }
-  - { offsetInCU: 0x64F, offset: 0x84CCE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwxx', symObjAddr: 0x1B90, symBinAddr: 0xE420, symSize: 0x10 }
-  - { offsetInCU: 0x663, offset: 0x84CE2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwcp', symObjAddr: 0x1BA0, symBinAddr: 0xE430, symSize: 0x30 }
-  - { offsetInCU: 0x677, offset: 0x84CF6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwca', symObjAddr: 0x1BD0, symBinAddr: 0xE460, symSize: 0x50 }
-  - { offsetInCU: 0x68B, offset: 0x84D0A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwta', symObjAddr: 0x1C40, symBinAddr: 0xE4B0, symSize: 0x40 }
-  - { offsetInCU: 0x69F, offset: 0x84D1E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwet', symObjAddr: 0x1C80, symBinAddr: 0xE4F0, symSize: 0x40 }
-  - { offsetInCU: 0x6B3, offset: 0x84D32, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwst', symObjAddr: 0x1CC0, symBinAddr: 0xE530, symSize: 0x50 }
-  - { offsetInCU: 0x6C7, offset: 0x84D46, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVMa', symObjAddr: 0x1D10, symBinAddr: 0xE580, symSize: 0x10 }
-  - { offsetInCU: 0x6DB, offset: 0x84D5A, size: 0x8, addend: 0x0, symName: '_$sypSgWOc', symObjAddr: 0x1D20, symBinAddr: 0xE590, symSize: 0x40 }
-  - { offsetInCU: 0x6EF, offset: 0x84D6E, size: 0x8, addend: 0x0, symName: '_$sSo7UITouchCSo8NSObjectCSH10ObjectiveCWl', symObjAddr: 0x1E30, symBinAddr: 0xE5D0, symSize: 0x50 }
-  - { offsetInCU: 0x703, offset: 0x84D82, size: 0x8, addend: 0x0, symName: '_$sSh8IteratorV8_VariantOyx__GSHRzlWOe', symObjAddr: 0x1E80, symBinAddr: 0xE620, symSize: 0x20 }
-  - { offsetInCU: 0x761, offset: 0x84DE0, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_SgWOe', symObjAddr: 0x21A0, symBinAddr: 0xE940, symSize: 0x14 }
-  - { offsetInCU: 0xCB4, offset: 0x85333, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC12touchesBegan_4withyShySo7UITouchCG_So7UIEventCtF', symObjAddr: 0x0, symBinAddr: 0xC8D0, symSize: 0x630 }
-  - { offsetInCU: 0xF39, offset: 0x855B8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC12touchesMoved_4withyShySo7UITouchCG_So7UIEventCtF', symObjAddr: 0x650, symBinAddr: 0xCF20, symSize: 0xE0 }
-  - { offsetInCU: 0xFB8, offset: 0x85637, size: 0x8, addend: 0x0, symName: '_$sSa6remove2atxSi_tF12CanvasNative15NSCTouchHandlerC7PointerV_Tg5', symObjAddr: 0x800, symBinAddr: 0xD0B0, symSize: 0xB0 }
-  - { offsetInCU: 0x102A, offset: 0x856A9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC6target6actionAEypSg_10ObjectiveC8SelectorVSgtcfc', symObjAddr: 0x1030, symBinAddr: 0xD8C0, symSize: 0xF0 }
-  - { offsetInCU: 0x1179, offset: 0x857F8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC6onMove33_044DDF836BDB3B89B481C6F58BB6EF6BLLyySo19UIGestureRecognizerC_ShySo7UITouchCGSgtF', symObjAddr: 0x1590, symBinAddr: 0xDE20, symSize: 0x4B0 }
-  - { offsetInCU: 0x18C2, offset: 0x85F41, size: 0x8, addend: 0x0, symName: '_$ss12_ArrayBufferV20_consumeAndCreateNewAByxGyF12CanvasNative15NSCTouchHandlerC7PointerV_Tg5', symObjAddr: 0x1EA0, symBinAddr: 0xE640, symSize: 0x20 }
-  - { offsetInCU: 0x195A, offset: 0x85FD9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC6canvasAcA9NSCCanvasC_tcfcTf4gn_n', symObjAddr: 0x1EC0, symBinAddr: 0xE660, symSize: 0x1F0 }
-  - { offsetInCU: 0x27, offset: 0x861A2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC14FAILED_TO_LOADSSvgZTo', symObjAddr: 0x0, symBinAddr: 0xE960, symSize: 0x30 }
-  - { offsetInCU: 0x4B, offset: 0x861C6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queueSo012OS_dispatch_E0CvpZ', symObjAddr: 0x2A0, symBinAddr: 0x12D31C8, symSize: 0x0 }
-  - { offsetInCU: 0x65, offset: 0x861E0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC14FAILED_TO_LOADSSvgZTo', symObjAddr: 0x0, symBinAddr: 0xE960, symSize: 0x30 }
-  - { offsetInCU: 0x98, offset: 0x86213, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queueSo012OS_dispatch_E0CvgZTo', symObjAddr: 0x160, symBinAddr: 0xEAC0, symSize: 0x30 }
-  - { offsetInCU: 0x104, offset: 0x8627F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCACycfcTo', symObjAddr: 0x200, symBinAddr: 0xEB60, symSize: 0x30 }
-  - { offsetInCU: 0x158, offset: 0x862D3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queue_WZ', symObjAddr: 0x30, symBinAddr: 0xE990, symSize: 0xF0 }
-  - { offsetInCU: 0x183, offset: 0x862FE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCMa', symObjAddr: 0x1E0, symBinAddr: 0xEB40, symSize: 0x20 }
-  - { offsetInCU: 0x197, offset: 0x86312, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCfETo', symObjAddr: 0x260, symBinAddr: 0xEBC0, symSize: 0x10 }
-  - { offsetInCU: 0x1C2, offset: 0x8633D, size: 0x8, addend: 0x0, symName: '_$sSo17OS_dispatch_queueCMa', symObjAddr: 0x270, symBinAddr: 0xEBD0, symSize: 0x2F }
-  - { offsetInCU: 0x34A, offset: 0x864C5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queueSo012OS_dispatch_E0CvgZ', symObjAddr: 0x120, symBinAddr: 0xEA80, symSize: 0x40 }
-  - { offsetInCU: 0x38A, offset: 0x86505, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCACycfC', symObjAddr: 0x190, symBinAddr: 0xEAF0, symSize: 0x20 }
-  - { offsetInCU: 0x39E, offset: 0x86519, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCACycfc', symObjAddr: 0x1B0, symBinAddr: 0xEB10, symSize: 0x30 }
-  - { offsetInCU: 0x3DA, offset: 0x86555, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCfD', symObjAddr: 0x230, symBinAddr: 0xEB90, symSize: 0x30 }
-  - { offsetInCU: 0x2B, offset: 0x865A3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC18createTextureCacheSo017CVOpenGLESTextureF3RefaSgyFZ', symObjAddr: 0x0, symBinAddr: 0xEC00, symSize: 0xA0 }
-  - { offsetInCU: 0x66, offset: 0x865DE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC18createTextureCacheSo017CVOpenGLESTextureF3RefaSgyFZTo', symObjAddr: 0xA0, symBinAddr: 0xECA0, symSize: 0xA0 }
-  - { offsetInCU: 0xF9, offset: 0x86671, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11createImageySo11CVBufferRefaSgSo022CVOpenGLESTextureCacheG0a_AFSo012CFDictionaryG0aSgs6UInt32Vs5Int32VA2p2NSitFZTo', symObjAddr: 0x1D0, symBinAddr: 0xEDD0, symSize: 0x100 }
-  - { offsetInCU: 0x1AD, offset: 0x86725, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11setupRenderAA9NSCRenderCyFZTo', symObjAddr: 0x300, symBinAddr: 0xEF00, symSize: 0x30 }
-  - { offsetInCU: 0x22D, offset: 0x867A5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC9drawFrameyySo8AVPlayerC_So0F15ItemVideoOutputCSo6CGSizeVAA9NSCRenderCs5Int32VANSbtFZTo', symObjAddr: 0x340, symBinAddr: 0xEF40, symSize: 0x90 }
-  - { offsetInCU: 0x2A6, offset: 0x8681E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11writeToFileyySo6NSDataC_SStKFZTo', symObjAddr: 0x4E0, symBinAddr: 0xF0E0, symSize: 0x140 }
-  - { offsetInCU: 0x345, offset: 0x868BD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCACycfcTo', symObjAddr: 0x670, symBinAddr: 0xF270, symSize: 0x30 }
-  - { offsetInCU: 0x398, offset: 0x86910, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC9drawFrameyySo8AVPlayerC_So0F15ItemVideoOutputCSo6CGSizeVAA9NSCRenderCs5Int32VANSbtFZTf4nnnnnndd_n', symObjAddr: 0x6D0, symBinAddr: 0xF2D0, symSize: 0x170 }
-  - { offsetInCU: 0x50B, offset: 0x86A83, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC7getFile33_F00B23A4165DD6ABFCD23C8811C7DF43LLyS2SKFZTf4nd_g', symObjAddr: 0x840, symBinAddr: 0xF440, symSize: 0x310 }
-  - { offsetInCU: 0x5EA, offset: 0x86B62, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCMa', symObjAddr: 0xB50, symBinAddr: 0xF750, symSize: 0x20 }
-  - { offsetInCU: 0x5FE, offset: 0x86B76, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOAEs5ErrorAAWl', symObjAddr: 0xB70, symBinAddr: 0xF770, symSize: 0x30 }
-  - { offsetInCU: 0x612, offset: 0x86B8A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwCP', symObjAddr: 0xBA0, symBinAddr: 0xF7A0, symSize: 0x30 }
-  - { offsetInCU: 0x626, offset: 0x86B9E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwxx', symObjAddr: 0xBD0, symBinAddr: 0xF7D0, symSize: 0x10 }
-  - { offsetInCU: 0x63A, offset: 0x86BB2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwca', symObjAddr: 0xBE0, symBinAddr: 0xF7E0, symSize: 0x40 }
-  - { offsetInCU: 0x64E, offset: 0x86BC6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwta', symObjAddr: 0xC30, symBinAddr: 0xF820, symSize: 0x30 }
-  - { offsetInCU: 0x662, offset: 0x86BDA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwet', symObjAddr: 0xC60, symBinAddr: 0xF850, symSize: 0x40 }
-  - { offsetInCU: 0x676, offset: 0x86BEE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwst', symObjAddr: 0xCA0, symBinAddr: 0xF890, symSize: 0x40 }
-  - { offsetInCU: 0x68A, offset: 0x86C02, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwug', symObjAddr: 0xCE0, symBinAddr: 0xF8D0, symSize: 0x10 }
-  - { offsetInCU: 0x69E, offset: 0x86C16, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwup', symObjAddr: 0xCF0, symBinAddr: 0xF8E0, symSize: 0x10 }
-  - { offsetInCU: 0x6B2, offset: 0x86C2A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwui', symObjAddr: 0xD00, symBinAddr: 0xF8F0, symSize: 0x10 }
-  - { offsetInCU: 0x6C6, offset: 0x86C3E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOMa', symObjAddr: 0xD10, symBinAddr: 0xF900, symSize: 0x10 }
-  - { offsetInCU: 0x74E, offset: 0x86CC6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP7_domainSSvgTW', symObjAddr: 0x3D0, symBinAddr: 0xEFD0, symSize: 0x10 }
-  - { offsetInCU: 0x76A, offset: 0x86CE2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP5_codeSivgTW', symObjAddr: 0x3E0, symBinAddr: 0xEFE0, symSize: 0x10 }
-  - { offsetInCU: 0x786, offset: 0x86CFE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP9_userInfoyXlSgvgTW', symObjAddr: 0x3F0, symBinAddr: 0xEFF0, symSize: 0x10 }
-  - { offsetInCU: 0x7A2, offset: 0x86D1A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP19_getEmbeddedNSErroryXlSgyFTW', symObjAddr: 0x400, symBinAddr: 0xF000, symSize: 0x10 }
-  - { offsetInCU: 0xA56, offset: 0x86FCE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC18createTextureCacheSo017CVOpenGLESTextureF3RefaSgyFZ', symObjAddr: 0x0, symBinAddr: 0xEC00, symSize: 0xA0 }
-  - { offsetInCU: 0xAEC, offset: 0x87064, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11createImageySo11CVBufferRefaSgSo022CVOpenGLESTextureCacheG0a_AFSo012CFDictionaryG0aSgs6UInt32Vs5Int32VA2p2NSitFZ', symObjAddr: 0x140, symBinAddr: 0xED40, symSize: 0x90 }
-  - { offsetInCU: 0xC71, offset: 0x871E9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11setupRenderAA9NSCRenderCyFZ', symObjAddr: 0x2D0, symBinAddr: 0xEED0, symSize: 0x30 }
-  - { offsetInCU: 0xCBB, offset: 0x87233, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC9drawFrameyySo8AVPlayerC_So0F15ItemVideoOutputCSo6CGSizeVAA9NSCRenderCs5Int32VANSbtFZ', symObjAddr: 0x330, symBinAddr: 0xEF30, symSize: 0x10 }
-  - { offsetInCU: 0xCDD, offset: 0x87255, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11writeToFileyySo6NSDataC_SStKFZ', symObjAddr: 0x410, symBinAddr: 0xF010, symSize: 0xD0 }
-  - { offsetInCU: 0xD8D, offset: 0x87305, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCACycfC', symObjAddr: 0x620, symBinAddr: 0xF220, symSize: 0x20 }
-  - { offsetInCU: 0xDA1, offset: 0x87319, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCACycfc', symObjAddr: 0x640, symBinAddr: 0xF240, symSize: 0x30 }
-  - { offsetInCU: 0xDD7, offset: 0x8734F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCfD', symObjAddr: 0x6A0, symBinAddr: 0xF2A0, symSize: 0x30 }
-  - { offsetInCU: 0x27, offset: 0x8746F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x0, symBinAddr: 0xF920, symSize: 0x10 }
-  - { offsetInCU: 0x71, offset: 0x874B9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZTo', symObjAddr: 0x10, symBinAddr: 0xF930, symSize: 0x60 }
-  - { offsetInCU: 0xF6, offset: 0x8753E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS2ftFZTo', symObjAddr: 0x80, symBinAddr: 0xF9A0, symSize: 0x50 }
-  - { offsetInCU: 0x193, offset: 0x875DB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS4ftFZTo', symObjAddr: 0xE0, symBinAddr: 0xFA00, symSize: 0x60 }
-  - { offsetInCU: 0x25C, offset: 0x876A4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS8ftFZTo', symObjAddr: 0x150, symBinAddr: 0xFA70, symSize: 0x90 }
-  - { offsetInCU: 0x339, offset: 0x87781, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCACycfcTo', symObjAddr: 0x230, symBinAddr: 0xFB50, symSize: 0x30 }
-  - { offsetInCU: 0x38D, offset: 0x877D5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCMa', symObjAddr: 0x290, symBinAddr: 0xFBB0, symSize: 0x14 }
-  - { offsetInCU: 0x4FD, offset: 0x87945, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x0, symBinAddr: 0xF920, symSize: 0x10 }
-  - { offsetInCU: 0x5A0, offset: 0x879E8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS2ftFZ', symObjAddr: 0x70, symBinAddr: 0xF990, symSize: 0x10 }
-  - { offsetInCU: 0x640, offset: 0x87A88, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS4ftFZ', symObjAddr: 0xD0, symBinAddr: 0xF9F0, symSize: 0x10 }
-  - { offsetInCU: 0x703, offset: 0x87B4B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS8ftFZ', symObjAddr: 0x140, symBinAddr: 0xFA60, symSize: 0x10 }
-  - { offsetInCU: 0x80F, offset: 0x87C57, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCACycfC', symObjAddr: 0x1E0, symBinAddr: 0xFB00, symSize: 0x20 }
-  - { offsetInCU: 0x823, offset: 0x87C6B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCACycfc', symObjAddr: 0x200, symBinAddr: 0xFB20, symSize: 0x30 }
-  - { offsetInCU: 0x859, offset: 0x87CA1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCfD', symObjAddr: 0x260, symBinAddr: 0xFB80, symSize: 0x30 }
-  - { offsetInCU: 0x27, offset: 0x87CEB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC10texImage2Dyys5Int64V_s5Int32VA4HSpys5UInt8VGSuSo6CGSizeVSbtFZ', symObjAddr: 0x0, symBinAddr: 0xFBD0, symSize: 0x30 }
-  - { offsetInCU: 0xA9, offset: 0x87D6D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC10texImage2Dyys5Int64V_s5Int32VA4HSpys5UInt8VGSuSo6CGSizeVSbtFZTo', symObjAddr: 0x30, symBinAddr: 0xFC00, symSize: 0x50 }
-  - { offsetInCU: 0x1A6, offset: 0x87E6A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC13texSubImage2Dyys5Int64V_s5Int32VA5HSpys5UInt8VGSuSo6CGSizeVSbtFZTo', symObjAddr: 0xC0, symBinAddr: 0xFC90, symSize: 0x50 }
-  - { offsetInCU: 0x289, offset: 0x87F4D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCACycfcTo', symObjAddr: 0x180, symBinAddr: 0xFD50, symSize: 0x30 }
-  - { offsetInCU: 0x2DD, offset: 0x87FA1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCMa', symObjAddr: 0x160, symBinAddr: 0xFD30, symSize: 0x20 }
-  - { offsetInCU: 0x487, offset: 0x8814B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC10texImage2Dyys5Int64V_s5Int32VA4HSpys5UInt8VGSuSo6CGSizeVSbtFZ', symObjAddr: 0x0, symBinAddr: 0xFBD0, symSize: 0x30 }
-  - { offsetInCU: 0x5DD, offset: 0x882A1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC13texSubImage2Dyys5Int64V_s5Int32VA5HSpys5UInt8VGSuSo6CGSizeVSbtFZ', symObjAddr: 0x80, symBinAddr: 0xFC50, symSize: 0x40 }
-  - { offsetInCU: 0x725, offset: 0x883E9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCACycfC', symObjAddr: 0x110, symBinAddr: 0xFCE0, symSize: 0x20 }
-  - { offsetInCU: 0x739, offset: 0x883FD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCACycfc', symObjAddr: 0x130, symBinAddr: 0xFD00, symSize: 0x30 }
-  - { offsetInCU: 0x76F, offset: 0x88433, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCfD', symObjAddr: 0x1B0, symBinAddr: 0xFD80, symSize: 0x2B }
-  - { offsetInCU: 0x61, offset: 0x884B7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7isDirtySbvgTo', symObjAddr: 0x10, symBinAddr: 0xFDC0, symSize: 0x20 }
-  - { offsetInCU: 0xB7, offset: 0x8850D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7isDirtySbvsTo', symObjAddr: 0x30, symBinAddr: 0xFDE0, symSize: 0x10 }
-  - { offsetInCU: 0x110, offset: 0x88566, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC6canvasAA9NSCCanvasCSgvgTo', symObjAddr: 0x40, symBinAddr: 0xFDF0, symSize: 0x40 }
-  - { offsetInCU: 0x168, offset: 0x885BE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC6canvasAA9NSCCanvasCSgvsTo', symObjAddr: 0xC0, symBinAddr: 0xFE70, symSize: 0x40 }
-  - { offsetInCU: 0x1C3, offset: 0x88619, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC3fbos6UInt32VvgTo', symObjAddr: 0x100, symBinAddr: 0xFEB0, symSize: 0x10 }
-  - { offsetInCU: 0x219, offset: 0x8866F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC3fbos6UInt32VvsTo', symObjAddr: 0x110, symBinAddr: 0xFEC0, symSize: 0x10 }
-  - { offsetInCU: 0x272, offset: 0x886C8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCACycfcTo', symObjAddr: 0x1C0, symBinAddr: 0xFF70, symSize: 0x80 }
-  - { offsetInCU: 0x2CA, offset: 0x88720, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frameACSo6CGRectV_tcfcTo', symObjAddr: 0x300, symBinAddr: 0x100B0, symSize: 0xA0 }
-  - { offsetInCU: 0x32C, offset: 0x88782, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5coderACSgSo7NSCoderC_tcfcTo', symObjAddr: 0x470, symBinAddr: 0x10220, symSize: 0x30 }
-  - { offsetInCU: 0x35E, offset: 0x887B4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC12bindDrawableyyFTo', symObjAddr: 0x520, symBinAddr: 0x10250, symSize: 0xA0 }
-  - { offsetInCU: 0x3DF, offset: 0x88835, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC14deleteDrawableyyFTo', symObjAddr: 0x600, symBinAddr: 0x102F0, symSize: 0x60 }
-  - { offsetInCU: 0x44F, offset: 0x888A5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7glkView_6drawInySo0C0C_So6CGRectVtFTo', symObjAddr: 0x670, symBinAddr: 0x10360, symSize: 0x50 }
-  - { offsetInCU: 0x4C1, offset: 0x88917, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frame7contextACSo6CGRectV_So11EAGLContextCtcfcTo', symObjAddr: 0x780, symBinAddr: 0x10470, symSize: 0x30 }
-  - { offsetInCU: 0x535, offset: 0x8898B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCMa', symObjAddr: 0x1A0, symBinAddr: 0xFF50, symSize: 0x20 }
-  - { offsetInCU: 0x55F, offset: 0x889B5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCfETo', symObjAddr: 0x7D0, symBinAddr: 0x104C0, symSize: 0x20 }
-  - { offsetInCU: 0x65D, offset: 0x88AB3, size: 0x8, addend: 0x0, symName: '_$sSo7GLKViewC12CanvasNativeE16snapshotWithDatayy10Foundation0F0VFTo', symObjAddr: 0xAF0, symBinAddr: 0x107E0, symSize: 0x80 }
-  - { offsetInCU: 0x69B, offset: 0x88AF1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC7isDirtySbvgTo', symObjAddr: 0xB70, symBinAddr: 0x10860, symSize: 0x20 }
-  - { offsetInCU: 0x6F1, offset: 0x88B47, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC7isDirtySbvsTo', symObjAddr: 0xB90, symBinAddr: 0x10880, symSize: 0x10 }
-  - { offsetInCU: 0x74A, offset: 0x88BA0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC8rendererAA9NSCCanvasCSgvgTo', symObjAddr: 0xBA0, symBinAddr: 0x10890, symSize: 0x20 }
-  - { offsetInCU: 0x7A2, offset: 0x88BF8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC8rendererAA9NSCCanvasCSgvsTo', symObjAddr: 0xBC0, symBinAddr: 0x108B0, symSize: 0x20 }
-  - { offsetInCU: 0x7FD, offset: 0x88C53, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvgTo', symObjAddr: 0xBE0, symBinAddr: 0x108D0, symSize: 0x40 }
-  - { offsetInCU: 0x853, offset: 0x88CA9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvsTo', symObjAddr: 0xC50, symBinAddr: 0x10940, symSize: 0x40 }
-  - { offsetInCU: 0x8E6, offset: 0x88D3C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCACycfcTo', symObjAddr: 0xDC0, symBinAddr: 0x10AB0, symSize: 0x80 }
-  - { offsetInCU: 0x93E, offset: 0x88D94, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5frameACSo6CGRectV_tcfcTo', symObjAddr: 0xF90, symBinAddr: 0x10C80, symSize: 0xA0 }
-  - { offsetInCU: 0x9A0, offset: 0x88DF6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5coderACSgSo7NSCoderC_tcfcTo', symObjAddr: 0x10E0, symBinAddr: 0x10DD0, symSize: 0x30 }
-  - { offsetInCU: 0x9D2, offset: 0x88E28, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC11deviceScaleSfyFTo', symObjAddr: 0x1110, symBinAddr: 0x10E00, symSize: 0xB0 }
-  - { offsetInCU: 0xA53, offset: 0x88EA9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC4drawyySo6CGRectVFTo', symObjAddr: 0x11D0, symBinAddr: 0x10EB0, symSize: 0x30 }
-  - { offsetInCU: 0xAB1, offset: 0x88F07, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCfETo', symObjAddr: 0x1250, symBinAddr: 0x10F30, symSize: 0x20 }
-  - { offsetInCU: 0xC63, offset: 0x890B9, size: 0x8, addend: 0x0, symName: '_$ss22_ContiguousArrayBufferV19_uninitializedCount15minimumCapacityAByxGSi_SitcfC12CanvasNative15NSCTouchHandlerC7PointerV_Tgm5', symObjAddr: 0x1470, symBinAddr: 0x110A0, symSize: 0x80 }
-  - { offsetInCU: 0xCE6, offset: 0x8913C, size: 0x8, addend: 0x0, symName: '_$ss22_ContiguousArrayBufferV19_uninitializedCount15minimumCapacityAByxGSi_SitcfCs5UInt8V_Tgm5', symObjAddr: 0x1570, symBinAddr: 0x11120, symSize: 0x70 }
-  - { offsetInCU: 0xD6A, offset: 0x891C0, size: 0x8, addend: 0x0, symName: '_$s10Foundation4DataV15_RepresentationOWOy', symObjAddr: 0x1750, symBinAddr: 0x11300, symSize: 0x40 }
-  - { offsetInCU: 0xD7E, offset: 0x891D4, size: 0x8, addend: 0x0, symName: '_$s10Foundation4DataV15_RepresentationOWOe', symObjAddr: 0x1790, symBinAddr: 0x11340, symSize: 0x40 }
-  - { offsetInCU: 0xD92, offset: 0x891E8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCMa', symObjAddr: 0x17D0, symBinAddr: 0x11380, symSize: 0x20 }
-  - { offsetInCU: 0xE6C, offset: 0x892C2, size: 0x8, addend: 0x0, symName: '_$sSaySayxGqd__c7ElementQyd__RszSTRd__lufCs5UInt8V_10Foundation4DataVTgm5Tf4g_n', symObjAddr: 0x1650, symBinAddr: 0x11200, symSize: 0x100 }
-  - { offsetInCU: 0x112B, offset: 0x89581, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC6canvasAA9NSCCanvasCSgvg', symObjAddr: 0x80, symBinAddr: 0xFE30, symSize: 0x40 }
-  - { offsetInCU: 0x11A8, offset: 0x895FE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCACycfc', symObjAddr: 0x120, symBinAddr: 0xFED0, symSize: 0x80 }
-  - { offsetInCU: 0x11EF, offset: 0x89645, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frameACSo6CGRectV_tcfc', symObjAddr: 0x240, symBinAddr: 0xFFF0, symSize: 0xC0 }
-  - { offsetInCU: 0x1251, offset: 0x896A7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5coderACSgSo7NSCoderC_tcfc', symObjAddr: 0x3A0, symBinAddr: 0x10150, symSize: 0xD0 }
-  - { offsetInCU: 0x12DA, offset: 0x89730, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7glkView_6drawInySo0C0C_So6CGRectVtF', symObjAddr: 0x660, symBinAddr: 0x10350, symSize: 0x10 }
-  - { offsetInCU: 0x12FB, offset: 0x89751, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frame7contextACSo6CGRectV_So11EAGLContextCtcfC', symObjAddr: 0x6C0, symBinAddr: 0x103B0, symSize: 0x90 }
-  - { offsetInCU: 0x130F, offset: 0x89765, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frame7contextACSo6CGRectV_So11EAGLContextCtcfc', symObjAddr: 0x750, symBinAddr: 0x10440, symSize: 0x30 }
-  - { offsetInCU: 0x1428, offset: 0x8987E, size: 0x8, addend: 0x0, symName: '_$sSo7GLKViewC12CanvasNativeE16snapshotWithDatayy10Foundation0F0VF', symObjAddr: 0x7F0, symBinAddr: 0x104E0, symSize: 0x300 }
-  - { offsetInCU: 0x17D2, offset: 0x89C28, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvg', symObjAddr: 0xC20, symBinAddr: 0x10910, symSize: 0x30 }
-  - { offsetInCU: 0x180F, offset: 0x89C65, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvs', symObjAddr: 0xC90, symBinAddr: 0x10980, symSize: 0x40 }
-  - { offsetInCU: 0x1836, offset: 0x89C8C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvM', symObjAddr: 0xCD0, symBinAddr: 0x109C0, symSize: 0x40 }
-  - { offsetInCU: 0x185B, offset: 0x89CB1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvM.resume.0', symObjAddr: 0xD10, symBinAddr: 0x10A00, symSize: 0x10 }
-  - { offsetInCU: 0x1882, offset: 0x89CD8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCACycfC', symObjAddr: 0xD20, symBinAddr: 0x10A10, symSize: 0x20 }
-  - { offsetInCU: 0x1896, offset: 0x89CEC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCACycfc', symObjAddr: 0xD40, symBinAddr: 0x10A30, symSize: 0x80 }
-  - { offsetInCU: 0x18DD, offset: 0x89D33, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5frameACSo6CGRectV_tcfc', symObjAddr: 0xED0, symBinAddr: 0x10BC0, symSize: 0xC0 }
-  - { offsetInCU: 0x193A, offset: 0x89D90, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5coderACSgSo7NSCoderC_tcfc', symObjAddr: 0x1030, symBinAddr: 0x10D20, symSize: 0xB0 }
-  - { offsetInCU: 0x19D6, offset: 0x89E2C, size: 0x8, addend: 0x0, symName: '_$ss12_ArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtF12CanvasNative15NSCTouchHandlerC7PointerV_Tg5', symObjAddr: 0x1270, symBinAddr: 0x10F50, symSize: 0xB0 }
-  - { offsetInCU: 0x1AB8, offset: 0x89F0E, size: 0x8, addend: 0x0, symName: '_$ss12_ArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtFs5UInt8V_Tg5', symObjAddr: 0x13D0, symBinAddr: 0x11000, symSize: 0xA0 }
-  - { offsetInCU: 0x1BC4, offset: 0x8A01A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7glkView_6drawInySo0C0C_So6CGRectVtFTf4ddn_n', symObjAddr: 0x15E0, symBinAddr: 0x11190, symSize: 0x70 }
-  - { offsetInCU: 0x1CBF, offset: 0x8A115, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC4drawyySo6CGRectVFTf4dn_n', symObjAddr: 0x17F0, symBinAddr: 0x113A0, symSize: 0x410 }
-  - { offsetInCU: 0x4F, offset: 0x8A52D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC5queue33_7ED578B0ED4B2B6F6887A622A7B49AA3LLSo012OS_dispatch_E0CvpZ', symObjAddr: 0x980, symBinAddr: 0x12D3310, symSize: 0x0 }
-  - { offsetInCU: 0x5D, offset: 0x8A53B, size: 0x8, addend: 0x0, symName: '_$sIegh_IeyBh_TR', symObjAddr: 0x0, symBinAddr: 0x119A0, symSize: 0x30 }
-  - { offsetInCU: 0x75, offset: 0x8A553, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC5queue33_7ED578B0ED4B2B6F6887A622A7B49AA3LL_WZ', symObjAddr: 0x30, symBinAddr: 0x119D0, symSize: 0xF0 }
-  - { offsetInCU: 0xBC, offset: 0x8A59A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF4SyncySbs5Int64V_So7UIImageCtFZTo', symObjAddr: 0x130, symBinAddr: 0x11AD0, symSize: 0x40 }
-  - { offsetInCU: 0x130, offset: 0x8A60E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZTo', symObjAddr: 0x3C0, symBinAddr: 0x11D60, symSize: 0x80 }
-  - { offsetInCU: 0x18F, offset: 0x8A66D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCACycfcTo', symObjAddr: 0x490, symBinAddr: 0x11E30, symSize: 0x30 }
-  - { offsetInCU: 0x1E2, offset: 0x8A6C0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZTf4nnnd_n', symObjAddr: 0x500, symBinAddr: 0x11EA0, symSize: 0x200 }
-  - { offsetInCU: 0x261, offset: 0x8A73F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCfETo', symObjAddr: 0x4F0, symBinAddr: 0x11E90, symSize: 0x10 }
-  - { offsetInCU: 0x29D, offset: 0x8A77B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCMa', symObjAddr: 0x700, symBinAddr: 0x120A0, symSize: 0x20 }
-  - { offsetInCU: 0x2BC, offset: 0x8A79A, size: 0x8, addend: 0x0, symName: '_$s10ObjectiveC8ObjCBoolVIeyBy_SbIegy_TRTA', symObjAddr: 0x740, symBinAddr: 0x120E0, symSize: 0x20 }
-  - { offsetInCU: 0x2E5, offset: 0x8A7C3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_TA', symObjAddr: 0x790, symBinAddr: 0x12130, symSize: 0x20 }
-  - { offsetInCU: 0x2F9, offset: 0x8A7D7, size: 0x8, addend: 0x0, symName: _block_copy_helper, symObjAddr: 0x7B0, symBinAddr: 0x12150, symSize: 0x20 }
-  - { offsetInCU: 0x30D, offset: 0x8A7EB, size: 0x8, addend: 0x0, symName: _block_destroy_helper, symObjAddr: 0x7D0, symBinAddr: 0x12170, symSize: 0x10 }
-  - { offsetInCU: 0x321, offset: 0x8A7FF, size: 0x8, addend: 0x0, symName: '_$sSay8Dispatch0A13WorkItemFlagsVGMa', symObjAddr: 0x850, symBinAddr: 0x121B0, symSize: 0x50 }
-  - { offsetInCU: 0x335, offset: 0x8A813, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_yyScMYccfU0_TA', symObjAddr: 0x8D0, symBinAddr: 0x12200, symSize: 0x20 }
-  - { offsetInCU: 0x369, offset: 0x8A847, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_yyScMYccfU_TA', symObjAddr: 0x910, symBinAddr: 0x12240, symSize: 0x20 }
-  - { offsetInCU: 0x4FE, offset: 0x8A9DC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF4SyncySbs5Int64V_So7UIImageCtFZ', symObjAddr: 0x120, symBinAddr: 0x11AC0, symSize: 0x10 }
-  - { offsetInCU: 0x58B, offset: 0x8AA69, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZ', symObjAddr: 0x170, symBinAddr: 0x11B10, symSize: 0x10 }
-  - { offsetInCU: 0x59F, offset: 0x8AA7D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_', symObjAddr: 0x180, symBinAddr: 0x11B20, symSize: 0x240 }
-  - { offsetInCU: 0x678, offset: 0x8AB56, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCACycfC', symObjAddr: 0x440, symBinAddr: 0x11DE0, symSize: 0x20 }
-  - { offsetInCU: 0x68C, offset: 0x8AB6A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCACycfc', symObjAddr: 0x460, symBinAddr: 0x11E00, symSize: 0x30 }
-  - { offsetInCU: 0x6C2, offset: 0x8ABA0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCfD', symObjAddr: 0x4C0, symBinAddr: 0x11E60, symSize: 0x30 }
-  - { offsetInCU: 0x27, offset: 0x8AC46, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfC', symObjAddr: 0x0, symBinAddr: 0x122B0, symSize: 0x20 }
-  - { offsetInCU: 0x77, offset: 0x8AC96, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfcTo', symObjAddr: 0x70, symBinAddr: 0x12320, symSize: 0x30 }
-  - { offsetInCU: 0xCB, offset: 0x8ACEA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCMa', symObjAddr: 0x50, symBinAddr: 0x12300, symSize: 0x20 }
-  - { offsetInCU: 0x216, offset: 0x8AE35, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfC', symObjAddr: 0x0, symBinAddr: 0x122B0, symSize: 0x20 }
-  - { offsetInCU: 0x22A, offset: 0x8AE49, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfc', symObjAddr: 0x20, symBinAddr: 0x122D0, symSize: 0x30 }
-  - { offsetInCU: 0x266, offset: 0x8AE85, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCfD', symObjAddr: 0xA0, symBinAddr: 0x12350, symSize: 0x2B }
-  - { offsetInCU: 0x26, offset: 0x8AECE, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_frombytes_vartime, symObjAddr: 0x0, symBinAddr: 0x348B60, symSize: 0x3990 }
-  - { offsetInCU: 0x40, offset: 0x8AEE8, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_k25519Precomp, symObjAddr: 0xEEC0, symBinAddr: 0xAD3690, symSize: 0x0 }
-  - { offsetInCU: 0x92, offset: 0x8AF3A, size: 0x8, addend: 0x0, symName: _d, symObjAddr: 0x14EC0, symBinAddr: 0xAD9690, symSize: 0x0 }
-  - { offsetInCU: 0xF6, offset: 0x8AF9E, size: 0x8, addend: 0x0, symName: _sqrtm1, symObjAddr: 0x14EE8, symBinAddr: 0xAD96B8, symSize: 0x0 }
-  - { offsetInCU: 0x10C, offset: 0x8AFB4, size: 0x8, addend: 0x0, symName: _d2, symObjAddr: 0x152F0, symBinAddr: 0xAD9AC0, symSize: 0x0 }
-  - { offsetInCU: 0x123, offset: 0x8AFCB, size: 0x8, addend: 0x0, symName: _Bi, symObjAddr: 0x14F30, symBinAddr: 0xAD9700, symSize: 0x0 }
-  - { offsetInCU: 0xE22, offset: 0x8BCCA, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_frombytes_vartime, symObjAddr: 0x0, symBinAddr: 0x348B60, symSize: 0x3990 }
-  - { offsetInCU: 0x4DAE, offset: 0x8FC56, size: 0x8, addend: 0x0, symName: _fe_mul_impl, symObjAddr: 0xE6E0, symBinAddr: 0x357240, symSize: 0x3E0 }
-  - { offsetInCU: 0x4FF1, offset: 0x8FE99, size: 0x8, addend: 0x0, symName: _fe_tobytes, symObjAddr: 0x7C20, symBinAddr: 0x350780, symSize: 0x270 }
-  - { offsetInCU: 0x582C, offset: 0x906D4, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_scalarmult_base, symObjAddr: 0x3990, symBinAddr: 0x34C4F0, symSize: 0xA10 }
-  - { offsetInCU: 0x684B, offset: 0x916F3, size: 0x8, addend: 0x0, symName: _table_select, symObjAddr: 0x43A0, symBinAddr: 0x34CF00, symSize: 0xA10 }
-  - { offsetInCU: 0x6EE9, offset: 0x91D91, size: 0x8, addend: 0x0, symName: _ge_madd, symObjAddr: 0x4DB0, symBinAddr: 0x34D910, symSize: 0x2B0 }
-  - { offsetInCU: 0x74BC, offset: 0x92364, size: 0x8, addend: 0x0, symName: _ge_p2_dbl, symObjAddr: 0x5060, symBinAddr: 0x34DBC0, symSize: 0xCD0 }
-  - { offsetInCU: 0x83FE, offset: 0x932A6, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_sc_reduce, symObjAddr: 0x5D30, symBinAddr: 0x34E890, symSize: 0xB40 }
-  - { offsetInCU: 0x8F67, offset: 0x93E0F, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_scalar_mult_generic_masked, symObjAddr: 0x6870, symBinAddr: 0x34F3D0, symSize: 0x13B0 }
-  - { offsetInCU: 0xA567, offset: 0x9540F, size: 0x8, addend: 0x0, symName: _fe_loose_invert, symObjAddr: 0x7FF0, symBinAddr: 0x350B50, symSize: 0x2A30 }
-  - { offsetInCU: 0xDC6D, offset: 0x98B15, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_public_from_private_generic_masked, symObjAddr: 0x7E90, symBinAddr: 0x3509F0, symSize: 0x160 }
-  - { offsetInCU: 0xDEE7, offset: 0x98D8F, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_invert, symObjAddr: 0xAA20, symBinAddr: 0x353580, symSize: 0x30 }
-  - { offsetInCU: 0xDFDC, offset: 0x98E84, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_isnegative, symObjAddr: 0xAA50, symBinAddr: 0x3535B0, symSize: 0x50 }
-  - { offsetInCU: 0xE051, offset: 0x98EF9, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_mul_ttt, symObjAddr: 0xAAA0, symBinAddr: 0x353600, symSize: 0x10 }
-  - { offsetInCU: 0xE0EC, offset: 0x98F94, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_neg, symObjAddr: 0xAAB0, symBinAddr: 0x353610, symSize: 0xB0 }
-  - { offsetInCU: 0xE217, offset: 0x990BF, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_tobytes, symObjAddr: 0xAB60, symBinAddr: 0x3536C0, symSize: 0x10 }
-  - { offsetInCU: 0xE4E9, offset: 0x99391, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_double_scalarmult_vartime, symObjAddr: 0xAB70, symBinAddr: 0x3536D0, symSize: 0x21A0 }
-  - { offsetInCU: 0x1118F, offset: 0x9C037, size: 0x8, addend: 0x0, symName: _x25519_ge_add, symObjAddr: 0xEAC0, symBinAddr: 0x357620, symSize: 0x2D1 }
-  - { offsetInCU: 0x117CF, offset: 0x9C677, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_sc_mask, symObjAddr: 0xCD10, symBinAddr: 0x355870, symSize: 0x20 }
-  - { offsetInCU: 0x11C6C, offset: 0x9CB14, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_sc_muladd, symObjAddr: 0xCD30, symBinAddr: 0x355890, symSize: 0x19B0 }
-  - { offsetInCU: 0x26, offset: 0x9DBC4, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_nohw_set_encrypt_key, symObjAddr: 0x0, symBinAddr: 0x357900, symSize: 0x800 }
-  - { offsetInCU: 0x41, offset: 0x9DBDF, size: 0x8, addend: 0x0, symName: _aes_nohw_rcon, symObjAddr: 0x1B10, symBinAddr: 0xAD9BA0, symSize: 0x0 }
-  - { offsetInCU: 0x484, offset: 0x9E022, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_nohw_set_encrypt_key, symObjAddr: 0x0, symBinAddr: 0x357900, symSize: 0x800 }
-  - { offsetInCU: 0x1B2B, offset: 0x9F6C9, size: 0x8, addend: 0x0, symName: _aes_nohw_sub_bytes, symObjAddr: 0x15F0, symBinAddr: 0x358EF0, symSize: 0x300 }
-  - { offsetInCU: 0x32EE, offset: 0xA0E8C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_nohw_encrypt, symObjAddr: 0x800, symBinAddr: 0x358100, symSize: 0x80 }
-  - { offsetInCU: 0x33DC, offset: 0xA0F7A, size: 0x8, addend: 0x0, symName: _aes_nohw_expand_round_keys, symObjAddr: 0x880, symBinAddr: 0x358180, symSize: 0x1A0 }
-  - { offsetInCU: 0x386D, offset: 0xA140B, size: 0x8, addend: 0x0, symName: _aes_nohw_to_batch, symObjAddr: 0xA20, symBinAddr: 0x358320, symSize: 0x420 }
-  - { offsetInCU: 0x3D7D, offset: 0xA191B, size: 0x8, addend: 0x0, symName: _aes_nohw_encrypt_batch, symObjAddr: 0xE40, symBinAddr: 0x358740, symSize: 0x380 }
-  - { offsetInCU: 0x424C, offset: 0xA1DEA, size: 0x8, addend: 0x0, symName: _aes_nohw_from_batch, symObjAddr: 0x11C0, symBinAddr: 0x358AC0, symSize: 0x250 }
-  - { offsetInCU: 0x498D, offset: 0xA252B, size: 0x8, addend: 0x0, symName: _aes_nohw_shift_rows, symObjAddr: 0x18F0, symBinAddr: 0x3591F0, symSize: 0x149 }
-  - { offsetInCU: 0x4BF9, offset: 0xA2797, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_nohw_ctr32_encrypt_blocks, symObjAddr: 0x1410, symBinAddr: 0x358D10, symSize: 0x1E0 }
-  - { offsetInCU: 0x26, offset: 0xA2BB8, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_from_montgomery_in_place, symObjAddr: 0x0, symBinAddr: 0x359340, symSize: 0x2DC }
-  - { offsetInCU: 0x1D2, offset: 0xA2D64, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_from_montgomery_in_place, symObjAddr: 0x0, symBinAddr: 0x359340, symSize: 0x2DC }
-  - { offsetInCU: 0x26, offset: 0xA2FBD, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_neg_inv_mod_r_u64, symObjAddr: 0x0, symBinAddr: 0x359620, symSize: 0x87 }
-  - { offsetInCU: 0x34, offset: 0xA2FCB, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_neg_inv_mod_r_u64, symObjAddr: 0x0, symBinAddr: 0x359620, symSize: 0x87 }
-  - { offsetInCU: 0x26, offset: 0xA30DB, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_little_endian_bytes_from_scalar, symObjAddr: 0x0, symBinAddr: 0x3596B0, symSize: 0x46 }
-  - { offsetInCU: 0x34, offset: 0xA30E9, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_little_endian_bytes_from_scalar, symObjAddr: 0x0, symBinAddr: 0x3596B0, symSize: 0x46 }
-  - { offsetInCU: 0x86, offset: 0xA324C, size: 0x8, addend: 0x0, symName: _Q_N0, symObjAddr: 0x15F0, symBinAddr: 0xAD9C20, symSize: 0x0 }
-  - { offsetInCU: 0xB8, offset: 0xA327E, size: 0x8, addend: 0x0, symName: _Q, symObjAddr: 0x1580, symBinAddr: 0xAD9BB0, symSize: 0x0 }
-  - { offsetInCU: 0xDA, offset: 0xA32A0, size: 0x8, addend: 0x0, symName: _N, symObjAddr: 0x15B0, symBinAddr: 0xAD9BE0, symSize: 0x0 }
-  - { offsetInCU: 0xF0, offset: 0xA32B6, size: 0x8, addend: 0x0, symName: _N_N0, symObjAddr: 0x15E0, symBinAddr: 0xAD9C10, symSize: 0x0 }
-  - { offsetInCU: 0x3B7, offset: 0xA357D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_elem_mul_mont, symObjAddr: 0x150, symBinAddr: 0x359700, symSize: 0x20 }
-  - { offsetInCU: 0x594, offset: 0xA375A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_scalar_mul_mont, symObjAddr: 0x250, symBinAddr: 0x359720, symSize: 0x20 }
-  - { offsetInCU: 0x63F, offset: 0xA3805, size: 0x8, addend: 0x0, symName: _nistz384_point_double, symObjAddr: 0x340, symBinAddr: 0x359740, symSize: 0x3A0 }
-  - { offsetInCU: 0x11A7, offset: 0xA436D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_point_add, symObjAddr: 0x6E0, symBinAddr: 0x359AE0, symSize: 0x140 }
-  - { offsetInCU: 0x14A2, offset: 0xA4668, size: 0x8, addend: 0x0, symName: _nistz384_point_add, symObjAddr: 0x820, symBinAddr: 0x359C20, symSize: 0x6B0 }
-  - { offsetInCU: 0x26DA, offset: 0xA58A0, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_point_mul, symObjAddr: 0xED0, symBinAddr: 0x35A2D0, symSize: 0x380 }
-  - { offsetInCU: 0x2D37, offset: 0xA5EFD, size: 0x8, addend: 0x0, symName: _p384_point_select_w5, symObjAddr: 0x1250, symBinAddr: 0x35A650, symSize: 0x170 }
-  - { offsetInCU: 0x2F2F, offset: 0xA60F5, size: 0x8, addend: 0x0, symName: _add_precomputed_w5, symObjAddr: 0x13C0, symBinAddr: 0x35A7C0, symSize: 0x1BF }
-  - { offsetInCU: 0x26, offset: 0xA6440, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_zero, symObjAddr: 0x0, symBinAddr: 0x35A980, symSize: 0x50 }
-  - { offsetInCU: 0xFA, offset: 0xA6514, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_zero, symObjAddr: 0x0, symBinAddr: 0x35A980, symSize: 0x50 }
-  - { offsetInCU: 0x18D, offset: 0xA65A7, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_equal, symObjAddr: 0x50, symBinAddr: 0x35A9D0, symSize: 0x60 }
-  - { offsetInCU: 0x2F1, offset: 0xA670B, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_equal_limb, symObjAddr: 0xB0, symBinAddr: 0x35AA30, symSize: 0x90 }
-  - { offsetInCU: 0x4C6, offset: 0xA68E0, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_even, symObjAddr: 0x140, symBinAddr: 0x35AAC0, symSize: 0x20 }
-  - { offsetInCU: 0x5E3, offset: 0xA69FD, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_less_than, symObjAddr: 0x160, symBinAddr: 0x35AAE0, symSize: 0xB0 }
-  - { offsetInCU: 0x696, offset: 0xA6AB0, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_less_than_limb, symObjAddr: 0x210, symBinAddr: 0x35AB90, symSize: 0x70 }
-  - { offsetInCU: 0x861, offset: 0xA6C7B, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_reduce_once, symObjAddr: 0x280, symBinAddr: 0x35AC00, symSize: 0x170 }
-  - { offsetInCU: 0xB67, offset: 0xA6F81, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_add_mod, symObjAddr: 0x3F0, symBinAddr: 0x35AD70, symSize: 0x270 }
-  - { offsetInCU: 0xE6A, offset: 0xA7284, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_sub_mod, symObjAddr: 0x660, symBinAddr: 0x35AFE0, symSize: 0x1A0 }
-  - { offsetInCU: 0x105D, offset: 0xA7477, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_shl_mod, symObjAddr: 0x800, symBinAddr: 0x35B180, symSize: 0x280 }
-  - { offsetInCU: 0x128C, offset: 0xA76A6, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_window5_split_window, symObjAddr: 0xC20, symBinAddr: 0x35B400, symSize: 0x20 }
-  - { offsetInCU: 0x12F3, offset: 0xA770D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_window5_unsplit_window, symObjAddr: 0xC40, symBinAddr: 0x35B420, symSize: 0x20 }
-  - { offsetInCU: 0x132A, offset: 0xA7744, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMB_shr, symObjAddr: 0xC60, symBinAddr: 0x35B440, symSize: 0x10 }
-  - { offsetInCU: 0x13AC, offset: 0xA77C6, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_limbs_mul_add_limb, symObjAddr: 0xC70, symBinAddr: 0x35B450, symSize: 0x4A }
-  - { offsetInCU: 0x26, offset: 0xA7952, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_CRYPTO_memcmp, symObjAddr: 0x0, symBinAddr: 0x35B4A0, symSize: 0x129 }
-  - { offsetInCU: 0x34, offset: 0xA7960, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_CRYPTO_memcmp, symObjAddr: 0x0, symBinAddr: 0x35B4A0, symSize: 0x129 }
-  - { offsetInCU: 0x34, offset: 0xA7A62, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_OPENSSL_ia32cap_P, symObjAddr: 0x3F0, symBinAddr: 0x12DA4F0, symSize: 0x0 }
-  - { offsetInCU: 0x26, offset: 0xA7AB7, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_OPENSSL_cpuid_setup, symObjAddr: 0x0, symBinAddr: 0x35B5D0, symSize: 0xF8 }
-  - { offsetInCU: 0xD5, offset: 0xA7B66, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_OPENSSL_cpuid_setup, symObjAddr: 0x0, symBinAddr: 0x35B5D0, symSize: 0xF8 }
-  - { offsetInCU: 0x26, offset: 0xA7CBB, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_scalar_mult_adx, symObjAddr: 0x0, symBinAddr: 0x35B6D0, symSize: 0x1210 }
-  - { offsetInCU: 0x92E, offset: 0xA85C3, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_scalar_mult_adx, symObjAddr: 0x0, symBinAddr: 0x35B6D0, symSize: 0x1210 }
-  - { offsetInCU: 0x5347, offset: 0xACFDC, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_scalarmult_base_adx, symObjAddr: 0x1210, symBinAddr: 0x35C8E0, symSize: 0x1E50 }
-  - { offsetInCU: 0x9B2F, offset: 0xB17C4, size: 0x8, addend: 0x0, symName: _inline_x25519_ge_dbl_4, symObjAddr: 0x3060, symBinAddr: 0x35E730, symSize: 0x361 }
-  - { offsetInCU: 0x26, offset: 0xB2BB1, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_CRYPTO_poly1305_init, symObjAddr: 0x0, symBinAddr: 0x35EAA0, symSize: 0xD0 }
-  - { offsetInCU: 0x303, offset: 0xB2E8E, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_CRYPTO_poly1305_init, symObjAddr: 0x0, symBinAddr: 0x35EAA0, symSize: 0xD0 }
-  - { offsetInCU: 0x5A4, offset: 0xB312F, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_CRYPTO_poly1305_update, symObjAddr: 0xD0, symBinAddr: 0x35EB70, symSize: 0x1C0 }
-  - { offsetInCU: 0x764, offset: 0xB32EF, size: 0x8, addend: 0x0, symName: _poly1305_blocks, symObjAddr: 0x5F0, symBinAddr: 0x35F090, symSize: 0x780 }
-  - { offsetInCU: 0x903, offset: 0xB348E, size: 0x8, addend: 0x0, symName: _poly1305_first_block, symObjAddr: 0x290, symBinAddr: 0x35ED30, symSize: 0x360 }
-  - { offsetInCU: 0xEFC, offset: 0xB3A87, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_CRYPTO_poly1305_finish, symObjAddr: 0xD70, symBinAddr: 0x35F810, symSize: 0xAA2 }
-  - { offsetInCU: 0x10, offset: 0xB4210, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_fiat_curve25519_adx_mul, symObjAddr: 0x0, symBinAddr: 0x3602B2, symSize: 0x2AF }
-  - { offsetInCU: 0x51, offset: 0xB4251, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_fiat_curve25519_adx_mul, symObjAddr: 0x0, symBinAddr: 0x3602B2, symSize: 0x2AF }
-  - { offsetInCU: 0x10, offset: 0xB4246, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_fiat_curve25519_adx_square, symObjAddr: 0x0, symBinAddr: 0x360561, symSize: 0x1F4 }
-  - { offsetInCU: 0x54, offset: 0xB428A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_fiat_curve25519_adx_square, symObjAddr: 0x0, symBinAddr: 0x360561, symSize: 0x1F4 }
-  - { offsetInCU: 0x26, offset: 0xB4292, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul, symObjAddr: 0x0, symBinAddr: 0x360760, symSize: 0x490 }
-  - { offsetInCU: 0x76, offset: 0xB42E2, size: 0x8, addend: 0x0, symName: _ecp_nistz256_precomputed, symObjAddr: 0x1000, symBinAddr: 0xADA000, symSize: 0x0 }
-  - { offsetInCU: 0xFA, offset: 0xB4366, size: 0x8, addend: 0x0, symName: _ONE, symObjAddr: 0x26000, symBinAddr: 0xAFF000, symSize: 0x0 }
-  - { offsetInCU: 0x35B, offset: 0xB45C7, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul, symObjAddr: 0x0, symBinAddr: 0x360760, symSize: 0x490 }
-  - { offsetInCU: 0xC5A, offset: 0xB4EC6, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul_base, symObjAddr: 0x490, symBinAddr: 0x360BF0, symSize: 0x300 }
-  - { offsetInCU: 0x1135, offset: 0xB53A1, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul_base_vartime, symObjAddr: 0x790, symBinAddr: 0x360EF0, symSize: 0x25D }
-  - { offsetInCU: 0x10, offset: 0xB5766, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ChaCha20_ctr32, symObjAddr: 0x0, symBinAddr: 0x361180, symSize: 0x3A0 }
-  - { offsetInCU: 0x48, offset: 0xB579E, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ChaCha20_ctr32, symObjAddr: 0x0, symBinAddr: 0x361180, symSize: 0x3A0 }
-  - { offsetInCU: 0x4D, offset: 0xB57A3, size: 0x8, addend: 0x0, symName: ChaCha20_ssse3, symObjAddr: 0x3A0, symBinAddr: 0x361520, symSize: 0x220 }
-  - { offsetInCU: 0x60, offset: 0xB57B6, size: 0x8, addend: 0x0, symName: ChaCha20_4x, symObjAddr: 0x5C0, symBinAddr: 0x361740, symSize: 0xA20 }
-  - { offsetInCU: 0x76, offset: 0xB57CC, size: 0x8, addend: 0x0, symName: ChaCha20_8x, symObjAddr: 0xFE0, symBinAddr: 0x362160, symSize: 0xB4C }
-  - { offsetInCU: 0x10, offset: 0xB57DE, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_encrypt, symObjAddr: 0x0, symBinAddr: 0x362CC0, symSize: 0x40 }
-  - { offsetInCU: 0x48, offset: 0xB5816, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_encrypt, symObjAddr: 0x0, symBinAddr: 0x362CC0, symSize: 0x40 }
-  - { offsetInCU: 0x4D, offset: 0xB581B, size: 0x8, addend: 0x0, symName: _aesni_encrypt2, symObjAddr: 0x40, symBinAddr: 0x362D00, symSize: 0x60 }
-  - { offsetInCU: 0x63, offset: 0xB5831, size: 0x8, addend: 0x0, symName: _aesni_encrypt3, symObjAddr: 0xA0, symBinAddr: 0x362D60, symSize: 0x70 }
-  - { offsetInCU: 0x79, offset: 0xB5847, size: 0x8, addend: 0x0, symName: _aesni_encrypt4, symObjAddr: 0x110, symBinAddr: 0x362DD0, symSize: 0x90 }
-  - { offsetInCU: 0x8F, offset: 0xB585D, size: 0x8, addend: 0x0, symName: _aesni_encrypt6, symObjAddr: 0x1A0, symBinAddr: 0x362E60, symSize: 0xE0 }
-  - { offsetInCU: 0xA5, offset: 0xB5873, size: 0x8, addend: 0x0, symName: _aesni_encrypt8, symObjAddr: 0x280, symBinAddr: 0x362F40, symSize: 0x110 }
-  - { offsetInCU: 0xD9, offset: 0xB58A7, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_ctr32_encrypt_blocks, symObjAddr: 0x390, symBinAddr: 0x363050, symSize: 0x940 }
-  - { offsetInCU: 0xEA, offset: 0xB58B8, size: 0x8, addend: 0x0, symName: __aesni_set_encrypt_key, symObjAddr: 0xCD0, symBinAddr: 0x363990, symSize: 0x44D }
-  - { offsetInCU: 0x10, offset: 0xB58AE, size: 0x8, addend: 0x0, symName: _vpaes_encrypt_core, symObjAddr: 0x0, symBinAddr: 0x363DE0, symSize: 0x160 }
-  - { offsetInCU: 0x3B, offset: 0xB58D9, size: 0x8, addend: 0x0, symName: _vpaes_encrypt_core, symObjAddr: 0x0, symBinAddr: 0x363DE0, symSize: 0x160 }
-  - { offsetInCU: 0x54, offset: 0xB58F2, size: 0x8, addend: 0x0, symName: _vpaes_encrypt_core_2x, symObjAddr: 0x160, symBinAddr: 0x363F40, symSize: 0x290 }
-  - { offsetInCU: 0x68, offset: 0xB5906, size: 0x8, addend: 0x0, symName: _vpaes_schedule_core, symObjAddr: 0x3F0, symBinAddr: 0x3641D0, symSize: 0xF0 }
-  - { offsetInCU: 0x7F, offset: 0xB591D, size: 0x8, addend: 0x0, symName: _vpaes_schedule_round, symObjAddr: 0x4E0, symBinAddr: 0x3642C0, symSize: 0x21 }
-  - { offsetInCU: 0x99, offset: 0xB5937, size: 0x8, addend: 0x0, symName: _vpaes_schedule_low_round, symObjAddr: 0x501, symBinAddr: 0x3642E1, symSize: 0x9F }
-  - { offsetInCU: 0xAF, offset: 0xB594D, size: 0x8, addend: 0x0, symName: _vpaes_schedule_transform, symObjAddr: 0x5A0, symBinAddr: 0x364380, symSize: 0x30 }
-  - { offsetInCU: 0xC2, offset: 0xB5960, size: 0x8, addend: 0x0, symName: _vpaes_schedule_mangle, symObjAddr: 0x5D0, symBinAddr: 0x3643B0, symSize: 0x50 }
-  - { offsetInCU: 0xE9, offset: 0xB5987, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_vpaes_set_encrypt_key, symObjAddr: 0x620, symBinAddr: 0x364400, symSize: 0x30 }
-  - { offsetInCU: 0xF7, offset: 0xB5995, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_vpaes_encrypt, symObjAddr: 0x650, symBinAddr: 0x364430, symSize: 0x20 }
-  - { offsetInCU: 0x11A, offset: 0xB59B8, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_vpaes_ctr32_encrypt_blocks, symObjAddr: 0x670, symBinAddr: 0x364450, symSize: 0xD0 }
-  - { offsetInCU: 0x112, offset: 0xB59B0, size: 0x8, addend: 0x0, symName: _vpaes_preheat, symObjAddr: 0x740, symBinAddr: 0x364520, symSize: 0x31 }
-  - { offsetInCU: 0x10, offset: 0xB59C0, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_mul_mont, symObjAddr: 0x0, symBinAddr: 0x364560, symSize: 0x2A0 }
-  - { offsetInCU: 0x45, offset: 0xB59F5, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_mul_mont, symObjAddr: 0x0, symBinAddr: 0x364560, symSize: 0x2A0 }
-  - { offsetInCU: 0x4C, offset: 0xB59FC, size: 0x8, addend: 0x0, symName: bn_mul4x_mont, symObjAddr: 0x2A0, symBinAddr: 0x364800, symSize: 0x560 }
-  - { offsetInCU: 0x62, offset: 0xB5A12, size: 0x8, addend: 0x0, symName: bn_sqr8x_mont, symObjAddr: 0x800, symBinAddr: 0x364D60, symSize: 0x220 }
-  - { offsetInCU: 0x79, offset: 0xB5A29, size: 0x8, addend: 0x0, symName: bn_mulx4x_mont, symObjAddr: 0xA20, symBinAddr: 0x364F80, symSize: 0x570 }
-  - { offsetInCU: 0x10, offset: 0xB5A38, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_mul_mont_gather5, symObjAddr: 0x0, symBinAddr: 0x365500, symSize: 0x660 }
-  - { offsetInCU: 0x4D, offset: 0xB5A75, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_mul_mont_gather5, symObjAddr: 0x0, symBinAddr: 0x365500, symSize: 0x660 }
-  - { offsetInCU: 0x54, offset: 0xB5A7C, size: 0x8, addend: 0x0, symName: bn_mul4x_mont_gather5, symObjAddr: 0x660, symBinAddr: 0x365B60, symSize: 0x100 }
-  - { offsetInCU: 0x63, offset: 0xB5A8B, size: 0x8, addend: 0x0, symName: mul4x_internal, symObjAddr: 0x760, symBinAddr: 0x365C60, symSize: 0x7E0 }
-  - { offsetInCU: 0x85, offset: 0xB5AAD, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_power5, symObjAddr: 0xF40, symBinAddr: 0x366440, symSize: 0x180 }
-  - { offsetInCU: 0xA3, offset: 0xB5ACB, size: 0x8, addend: 0x0, symName: __bn_sqr8x_internal, symObjAddr: 0x10C0, symBinAddr: 0x3665C0, symSize: 0x579 }
-  - { offsetInCU: 0xAA, offset: 0xB5AD2, size: 0x8, addend: 0x0, symName: __bn_sqr8x_reduction, symObjAddr: 0x1639, symBinAddr: 0x366B39, symSize: 0x347 }
-  - { offsetInCU: 0xC0, offset: 0xB5AE8, size: 0x8, addend: 0x0, symName: __bn_post4x_internal, symObjAddr: 0x1980, symBinAddr: 0x366E80, symSize: 0xA0 }
-  - { offsetInCU: 0xD9, offset: 0xB5B01, size: 0x8, addend: 0x0, symName: bn_mulx4x_mont_gather5, symObjAddr: 0x1A20, symBinAddr: 0x366F20, symSize: 0xE0 }
-  - { offsetInCU: 0xE8, offset: 0xB5B10, size: 0x8, addend: 0x0, symName: mulx4x_internal, symObjAddr: 0x1B00, symBinAddr: 0x367000, symSize: 0x7E0 }
-  - { offsetInCU: 0xF9, offset: 0xB5B21, size: 0x8, addend: 0x0, symName: bn_powerx5, symObjAddr: 0x22E0, symBinAddr: 0x3677E0, symSize: 0x160 }
-  - { offsetInCU: 0x128, offset: 0xB5B50, size: 0x8, addend: 0x0, symName: __bn_sqrx8x_internal, symObjAddr: 0x2440, symBinAddr: 0x367940, symSize: 0x637 }
-  - { offsetInCU: 0x12F, offset: 0xB5B57, size: 0x8, addend: 0x0, symName: __bn_sqrx8x_reduction, symObjAddr: 0x2A77, symBinAddr: 0x367F77, symSize: 0x329 }
-  - { offsetInCU: 0x145, offset: 0xB5B6D, size: 0x8, addend: 0x0, symName: __bn_postx4x_internal, symObjAddr: 0x2DA0, symBinAddr: 0x3682A0, symSize: 0x90 }
-  - { offsetInCU: 0x163, offset: 0xB5B8B, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_scatter5, symObjAddr: 0x2E30, symBinAddr: 0x368330, symSize: 0x30 }
-  - { offsetInCU: 0x178, offset: 0xB5BA0, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_gather5, symObjAddr: 0x2E60, symBinAddr: 0x368360, symSize: 0x27F }
-  - { offsetInCU: 0x10, offset: 0xB5BA2, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ecp_nistz256_neg, symObjAddr: 0x0, symBinAddr: 0x3685E0, symSize: 0x80 }
-  - { offsetInCU: 0x4A, offset: 0xB5BDC, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ecp_nistz256_neg, symObjAddr: 0x0, symBinAddr: 0x3685E0, symSize: 0x80 }
-  - { offsetInCU: 0x64, offset: 0xB5BF6, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_scalar_mul_mont, symObjAddr: 0x80, symBinAddr: 0x368660, symSize: 0x360 }
-  - { offsetInCU: 0x7E, offset: 0xB5C10, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_scalar_sqr_rep_mont, symObjAddr: 0x3E0, symBinAddr: 0x3689C0, symSize: 0x300 }
-  - { offsetInCU: 0x85, offset: 0xB5C17, size: 0x8, addend: 0x0, symName: ecp_nistz256_ord_mul_montx, symObjAddr: 0x6E0, symBinAddr: 0x368CC0, symSize: 0x3C0 }
-  - { offsetInCU: 0x9B, offset: 0xB5C2D, size: 0x8, addend: 0x0, symName: ecp_nistz256_ord_sqr_montx, symObjAddr: 0xAA0, symBinAddr: 0x369080, symSize: 0x320 }
-  - { offsetInCU: 0xB5, offset: 0xB5C47, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_mul_mont, symObjAddr: 0xDC0, symBinAddr: 0x3693A0, symSize: 0xA0 }
-  - { offsetInCU: 0xC4, offset: 0xB5C56, size: 0x8, addend: 0x0, symName: __ecp_nistz256_mul_montq, symObjAddr: 0xE60, symBinAddr: 0x369440, symSize: 0x240 }
-  - { offsetInCU: 0xE1, offset: 0xB5C73, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_sqr_mont, symObjAddr: 0x10A0, symBinAddr: 0x369680, symSize: 0x80 }
-  - { offsetInCU: 0xF0, offset: 0xB5C82, size: 0x8, addend: 0x0, symName: __ecp_nistz256_sqr_montq, symObjAddr: 0x1120, symBinAddr: 0x369700, symSize: 0x1A0 }
-  - { offsetInCU: 0x106, offset: 0xB5C98, size: 0x8, addend: 0x0, symName: __ecp_nistz256_mul_montx, symObjAddr: 0x12C0, symBinAddr: 0x3698A0, symSize: 0x260 }
-  - { offsetInCU: 0x11C, offset: 0xB5CAE, size: 0x8, addend: 0x0, symName: __ecp_nistz256_sqr_montx, symObjAddr: 0x1520, symBinAddr: 0x369B00, symSize: 0x1C0 }
-  - { offsetInCU: 0x142, offset: 0xB5CD4, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ecp_nistz256_select_w5, symObjAddr: 0x16E0, symBinAddr: 0x369CC0, symSize: 0xE0 }
-  - { offsetInCU: 0x158, offset: 0xB5CEA, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ecp_nistz256_select_w7, symObjAddr: 0x17C0, symBinAddr: 0x369DA0, symSize: 0xC0 }
-  - { offsetInCU: 0x162, offset: 0xB5CF4, size: 0x8, addend: 0x0, symName: ecp_nistz256_avx2_select_w5, symObjAddr: 0x1880, symBinAddr: 0x369E60, symSize: 0xC0 }
-  - { offsetInCU: 0x178, offset: 0xB5D0A, size: 0x8, addend: 0x0, symName: ecp_nistz256_avx2_select_w7, symObjAddr: 0x1940, symBinAddr: 0x369F20, symSize: 0xE0 }
-  - { offsetInCU: 0x188, offset: 0xB5D1A, size: 0x8, addend: 0x0, symName: __ecp_nistz256_add_toq, symObjAddr: 0x1A20, symBinAddr: 0x36A000, symSize: 0x60 }
-  - { offsetInCU: 0x1A0, offset: 0xB5D32, size: 0x8, addend: 0x0, symName: __ecp_nistz256_sub_fromq, symObjAddr: 0x1A80, symBinAddr: 0x36A060, symSize: 0x60 }
-  - { offsetInCU: 0x1B1, offset: 0xB5D43, size: 0x8, addend: 0x0, symName: __ecp_nistz256_subq, symObjAddr: 0x1AE0, symBinAddr: 0x36A0C0, symSize: 0x40 }
-  - { offsetInCU: 0x1CC, offset: 0xB5D5E, size: 0x8, addend: 0x0, symName: __ecp_nistz256_mul_by_2q, symObjAddr: 0x1B20, symBinAddr: 0x36A100, symSize: 0x60 }
-  - { offsetInCU: 0x1ED, offset: 0xB5D7F, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_double, symObjAddr: 0x1B80, symBinAddr: 0x36A160, symSize: 0x320 }
-  - { offsetInCU: 0x200, offset: 0xB5D92, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_add, symObjAddr: 0x1EA0, symBinAddr: 0x36A480, symSize: 0x780 }
-  - { offsetInCU: 0x21D, offset: 0xB5DAF, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_add_affine, symObjAddr: 0x2620, symBinAddr: 0x36AC00, symSize: 0x580 }
-  - { offsetInCU: 0x222, offset: 0xB5DB4, size: 0x8, addend: 0x0, symName: __ecp_nistz256_add_tox, symObjAddr: 0x2BA0, symBinAddr: 0x36B180, symSize: 0x60 }
-  - { offsetInCU: 0x23A, offset: 0xB5DCC, size: 0x8, addend: 0x0, symName: __ecp_nistz256_sub_fromx, symObjAddr: 0x2C00, symBinAddr: 0x36B1E0, symSize: 0x60 }
-  - { offsetInCU: 0x24B, offset: 0xB5DDD, size: 0x8, addend: 0x0, symName: __ecp_nistz256_subx, symObjAddr: 0x2C60, symBinAddr: 0x36B240, symSize: 0x60 }
-  - { offsetInCU: 0x266, offset: 0xB5DF8, size: 0x8, addend: 0x0, symName: __ecp_nistz256_mul_by_2x, symObjAddr: 0x2CC0, symBinAddr: 0x36B2A0, symSize: 0x60 }
-  - { offsetInCU: 0x27F, offset: 0xB5E11, size: 0x8, addend: 0x0, symName: ecp_nistz256_point_doublex, symObjAddr: 0x2D20, symBinAddr: 0x36B300, symSize: 0x320 }
-  - { offsetInCU: 0x292, offset: 0xB5E24, size: 0x8, addend: 0x0, symName: ecp_nistz256_point_addx, symObjAddr: 0x3040, symBinAddr: 0x36B620, symSize: 0x760 }
-  - { offsetInCU: 0x2AF, offset: 0xB5E41, size: 0x8, addend: 0x0, symName: ecp_nistz256_point_add_affinex, symObjAddr: 0x37A0, symBinAddr: 0x36BD80, symSize: 0x555 }
-  - { offsetInCU: 0x10, offset: 0xB5E40, size: 0x8, addend: 0x0, symName: _aesni_ctr32_ghash_6x, symObjAddr: 0x0, symBinAddr: 0x36C2E0, symSize: 0x5A0 }
-  - { offsetInCU: 0x3D, offset: 0xB5E6D, size: 0x8, addend: 0x0, symName: _aesni_ctr32_ghash_6x, symObjAddr: 0x0, symBinAddr: 0x36C2E0, symSize: 0x5A0 }
-  - { offsetInCU: 0x61, offset: 0xB5E91, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aesni_gcm_decrypt, symObjAddr: 0x5A0, symBinAddr: 0x36C880, symSize: 0x140 }
-  - { offsetInCU: 0x63, offset: 0xB5E93, size: 0x8, addend: 0x0, symName: _aesni_ctr32_6x, symObjAddr: 0x6E0, symBinAddr: 0x36C9C0, symSize: 0x180 }
-  - { offsetInCU: 0x8D, offset: 0xB5EBD, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aesni_gcm_encrypt, symObjAddr: 0x860, symBinAddr: 0x36CB40, symSize: 0x423 }
-  - { offsetInCU: 0x10, offset: 0xB5EB8, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_init_clmul, symObjAddr: 0x0, symBinAddr: 0x36CF80, symSize: 0x260 }
-  - { offsetInCU: 0x48, offset: 0xB5EF0, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_init_clmul, symObjAddr: 0x0, symBinAddr: 0x36CF80, symSize: 0x260 }
-  - { offsetInCU: 0x5F, offset: 0xB5F07, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_gmult_clmul, symObjAddr: 0x260, symBinAddr: 0x36D1E0, symSize: 0xC0 }
-  - { offsetInCU: 0x75, offset: 0xB5F1D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_ghash_clmul, symObjAddr: 0x320, symBinAddr: 0x36D2A0, symSize: 0x660 }
-  - { offsetInCU: 0x88, offset: 0xB5F30, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_init_avx, symObjAddr: 0x980, symBinAddr: 0x36D900, symSize: 0x1A0 }
-  - { offsetInCU: 0x9F, offset: 0xB5F47, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_ghash_avx, symObjAddr: 0xB20, symBinAddr: 0x36DAA0, symSize: 0x697 }
-  - { offsetInCU: 0x10, offset: 0xB5F46, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha512_block_data_order, symObjAddr: 0x0, symBinAddr: 0x36E140, symSize: 0x1240 }
-  - { offsetInCU: 0x51, offset: 0xB5F87, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha512_block_data_order, symObjAddr: 0x0, symBinAddr: 0x36E140, symSize: 0x1240 }
-  - { offsetInCU: 0x5A, offset: 0xB5F90, size: 0x8, addend: 0x0, symName: sha512_block_data_order_avx, symObjAddr: 0x1240, symBinAddr: 0x36F380, symSize: 0x1176 }
-  - { offsetInCU: 0x10, offset: 0xB5F92, size: 0x8, addend: 0x0, symName: poly_hash_ad_internal, symObjAddr: 0x0, symBinAddr: 0x370500, symSize: 0x200 }
-  - { offsetInCU: 0x44, offset: 0xB5FC6, size: 0x8, addend: 0x0, symName: poly_hash_ad_internal, symObjAddr: 0x0, symBinAddr: 0x370500, symSize: 0x200 }
-  - { offsetInCU: 0x66, offset: 0xB5FE8, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_chacha20_poly1305_open, symObjAddr: 0x200, symBinAddr: 0x370700, symSize: 0x21C0 }
-  - { offsetInCU: 0x7C, offset: 0xB5FFE, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_chacha20_poly1305_seal, symObjAddr: 0x23C0, symBinAddr: 0x3728C0, symSize: 0x1D2D }
-  - { offsetInCU: 0x83, offset: 0xB6005, size: 0x8, addend: 0x0, symName: process_extra_in_trailer, symObjAddr: 0x40ED, symBinAddr: 0x3745ED, symSize: 0x553 }
-  - { offsetInCU: 0x9C, offset: 0xB601E, size: 0x8, addend: 0x0, symName: chacha20_poly1305_open_avx2, symObjAddr: 0x4640, symBinAddr: 0x374B40, symSize: 0x25C0 }
-  - { offsetInCU: 0xB2, offset: 0xB6034, size: 0x8, addend: 0x0, symName: chacha20_poly1305_seal_avx2, symObjAddr: 0x6C00, symBinAddr: 0x377100, symSize: 0x2F01 }
-  - { offsetInCU: 0x10, offset: 0xB6036, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha256_block_data_order, symObjAddr: 0x0, symBinAddr: 0x37A040, symSize: 0x1200 }
-  - { offsetInCU: 0x51, offset: 0xB6077, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha256_block_data_order, symObjAddr: 0x0, symBinAddr: 0x37A040, symSize: 0x1200 }
-  - { offsetInCU: 0x5D, offset: 0xB6083, size: 0x8, addend: 0x0, symName: sha256_block_data_order_shaext, symObjAddr: 0x1200, symBinAddr: 0x37B240, symSize: 0x340 }
-  - { offsetInCU: 0x72, offset: 0xB6098, size: 0x8, addend: 0x0, symName: sha256_block_data_order_ssse3, symObjAddr: 0x1540, symBinAddr: 0x37B580, symSize: 0xEC0 }
-  - { offsetInCU: 0x86, offset: 0xB60AC, size: 0x8, addend: 0x0, symName: sha256_block_data_order_avx, symObjAddr: 0x2400, symBinAddr: 0x37C440, symSize: 0xEF7 }
+  - { offsetInCU: 0x34, offset: 0x795F8, size: 0x8, addend: 0x0, symName: _CanvasNativeVersionString, symObjAddr: 0x0, symBinAddr: 0xA9D000, symSize: 0x0 }
+  - { offsetInCU: 0x69, offset: 0x7962D, size: 0x8, addend: 0x0, symName: _CanvasNativeVersionNumber, symObjAddr: 0x38, symBinAddr: 0xA9D038, symSize: 0x0 }
+  - { offsetInCU: 0x3F, offset: 0x79682, size: 0x8, addend: 0x0, symName: ___swift_memcpy16_8, symObjAddr: 0x40, symBinAddr: 0x1FC0, symSize: 0x10 }
+  - { offsetInCU: 0x53, offset: 0x79696, size: 0x8, addend: 0x0, symName: ___swift_noop_void_return, symObjAddr: 0x50, symBinAddr: 0x1FD0, symSize: 0x10 }
+  - { offsetInCU: 0x67, offset: 0x796AA, size: 0x8, addend: 0x0, symName: '_$sSo6CGSizeVwet', symObjAddr: 0x60, symBinAddr: 0x1FE0, symSize: 0x20 }
+  - { offsetInCU: 0x7B, offset: 0x796BE, size: 0x8, addend: 0x0, symName: '_$sSo6CGSizeVwst', symObjAddr: 0x80, symBinAddr: 0x2000, symSize: 0x30 }
+  - { offsetInCU: 0x8F, offset: 0x796D2, size: 0x8, addend: 0x0, symName: '_$sSo6CGRectVwCP', symObjAddr: 0xD0, symBinAddr: 0x2050, symSize: 0x30 }
+  - { offsetInCU: 0xA3, offset: 0x796E6, size: 0x8, addend: 0x0, symName: ___swift_memcpy32_8, symObjAddr: 0x100, symBinAddr: 0x2080, symSize: 0x20 }
+  - { offsetInCU: 0xB7, offset: 0x796FA, size: 0x8, addend: 0x0, symName: '_$sSo6CGRectVwet', symObjAddr: 0x120, symBinAddr: 0x20A0, symSize: 0x20 }
+  - { offsetInCU: 0xCB, offset: 0x7970E, size: 0x8, addend: 0x0, symName: '_$sSo6CGRectVwst', symObjAddr: 0x140, symBinAddr: 0x20C0, symSize: 0x30 }
+  - { offsetInCU: 0x4F, offset: 0x798F7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC11_WriteQueue33_05178D28796EA758448493B56DC45144LLSo011NSOperationE0CSgvpZ', symObjAddr: 0x30B0, symBinAddr: 0x13639E0, symSize: 0x0 }
+  - { offsetInCU: 0x69, offset: 0x79911, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10_ReadQueue33_05178D28796EA758448493B56DC45144LLSo011NSOperationE0CSgvpZ', symObjAddr: 0x30B8, symBinAddr: 0x13639E8, symSize: 0x0 }
+  - { offsetInCU: 0x9D, offset: 0x79945, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC19getBytesFromUIImageySo13NSMutableDataCSo0G0CFZTo', symObjAddr: 0x10, symBinAddr: 0x2190, symSize: 0x40 }
+  - { offsetInCU: 0xF3, offset: 0x7999B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13createPatternys5Int64VAF_So7UIImageCSStFZTo', symObjAddr: 0x60, symBinAddr: 0x21E0, symSize: 0x60 }
+  - { offsetInCU: 0x144, offset: 0x799EC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC25loadImageAssetWithContextySbs5Int64V_So7UIImageCtFZTo', symObjAddr: 0xD0, symBinAddr: 0x2250, symSize: 0x40 }
+  - { offsetInCU: 0x19F, offset: 0x79A47, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dyys5Int64V_So7UIImageCS2ftFZTo', symObjAddr: 0x120, symBinAddr: 0x22A0, symSize: 0x50 }
+  - { offsetInCU: 0x204, offset: 0x79AAC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dy2dw2dhys5Int64V_So7UIImageCS4ftFZTo', symObjAddr: 0x180, symBinAddr: 0x2300, symSize: 0x60 }
+  - { offsetInCU: 0x27D, offset: 0x79B25, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2sx2sy2sw2sh2dx2dy2dw2dhys5Int64V_So7UIImageCS8ftFZTo', symObjAddr: 0x1F0, symBinAddr: 0x2370, symSize: 0x90 }
+  - { offsetInCU: 0x2DA, offset: 0x79B82, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23initWebGPUWithViewLayerys5Int64VAF_AFs6UInt32VAHtFZTo', symObjAddr: 0x290, symBinAddr: 0x2410, symSize: 0x20 }
+  - { offsetInCU: 0x35C, offset: 0x79C04, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC18initWebGPUWithViewys5Int64VAF_AFs6UInt32VAHtFZTo', symObjAddr: 0x2C0, symBinAddr: 0x2440, symSize: 0x20 }
+  - { offsetInCU: 0x40B, offset: 0x79CB3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14initGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbtFZTo', symObjAddr: 0x350, symBinAddr: 0x24D0, symSize: 0x80 }
+  - { offsetInCU: 0x4D0, offset: 0x79D78, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC20initSharedGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbAFtFZTo', symObjAddr: 0x440, symBinAddr: 0x25C0, symSize: 0x80 }
+  - { offsetInCU: 0x59F, offset: 0x79E47, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC24initGLWithWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbtFZTo', symObjAddr: 0x530, symBinAddr: 0x26B0, symSize: 0x80 }
+  - { offsetInCU: 0x669, offset: 0x79F11, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC26initSharedGLWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbAFtFZTo', symObjAddr: 0x630, symBinAddr: 0x27B0, symSize: 0x90 }
+  - { offsetInCU: 0x701, offset: 0x79FA9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15resize2DContextyys5Int64V_S2ftFZTo', symObjAddr: 0x6D0, symBinAddr: 0x2850, symSize: 0x10 }
+  - { offsetInCU: 0x768, offset: 0x7A010, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14flush2DContextyys5Int64VFZTo', symObjAddr: 0x6F0, symBinAddr: 0x2870, symSize: 0x10 }
+  - { offsetInCU: 0x7BF, offset: 0x7A067, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC7flushGLySbs5Int64VFZTo', symObjAddr: 0x710, symBinAddr: 0x2890, symSize: 0x10 }
+  - { offsetInCU: 0x816, offset: 0x7A0BE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9releaseGLyys5Int64VFZTo', symObjAddr: 0x730, symBinAddr: 0x28B0, symSize: 0x10 }
+  - { offsetInCU: 0x86D, offset: 0x7A115, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC12getGLPointerys5Int64VAFFZTo', symObjAddr: 0x750, symBinAddr: 0x28D0, symSize: 0x10 }
+  - { offsetInCU: 0x8C4, offset: 0x7A16C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC16releaseGLPointeryys5Int64VFZTo', symObjAddr: 0x770, symBinAddr: 0x28F0, symSize: 0x10 }
+  - { offsetInCU: 0x943, offset: 0x7A1EB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15create2DContextys5Int64VAF_s5Int32VAHSbSfA2HSfAHtFZTo', symObjAddr: 0x790, symBinAddr: 0x2910, symSize: 0x40 }
+  - { offsetInCU: 0x9EE, offset: 0x7A296, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23updateGLSurfaceWithViewyys5Int64V_s5Int32VAhFtFZTo', symObjAddr: 0x7E0, symBinAddr: 0x2960, symSize: 0x20 }
+  - { offsetInCU: 0xA61, offset: 0x7A309, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC6test2Dyys5Int64VFZTo', symObjAddr: 0x810, symBinAddr: 0x2990, symSize: 0x10 }
+  - { offsetInCU: 0xAB8, offset: 0x7A360, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13testToDataURLySSs5Int64VFZTo', symObjAddr: 0x880, symBinAddr: 0x2A00, symSize: 0x70 }
+  - { offsetInCU: 0xB43, offset: 0x7A3EB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZTo', symObjAddr: 0xA90, symBinAddr: 0x2C10, symSize: 0xA0 }
+  - { offsetInCU: 0xB94, offset: 0x7A43C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZTo', symObjAddr: 0xD90, symBinAddr: 0x2F10, symSize: 0xA0 }
+  - { offsetInCU: 0xBE5, offset: 0x7A48D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZTo', symObjAddr: 0x10F0, symBinAddr: 0x3270, symSize: 0xA0 }
+  - { offsetInCU: 0xC41, offset: 0x7A4E9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZTo', symObjAddr: 0x1540, symBinAddr: 0x36C0, symSize: 0xD0 }
+  - { offsetInCU: 0xC89, offset: 0x7A531, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC32getPixelsPerInchForCurrentDeviceSSyFZTo', symObjAddr: 0x1620, symBinAddr: 0x37A0, symSize: 0x40 }
+  - { offsetInCU: 0xCE9, offset: 0x7A591, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCACycfcTo', symObjAddr: 0x16B0, symBinAddr: 0x3830, symSize: 0x30 }
+  - { offsetInCU: 0xD3C, offset: 0x7A5E4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC19getBytesFromUIImageySo13NSMutableDataCSo0G0CFZTf4nd_n', symObjAddr: 0x1720, symBinAddr: 0x38A0, symSize: 0x300 }
+  - { offsetInCU: 0xF6C, offset: 0x7A814, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13createPatternys5Int64VAF_So7UIImageCSStFZTf4nnnd_n', symObjAddr: 0x1A20, symBinAddr: 0x3BA0, symSize: 0x260 }
+  - { offsetInCU: 0x1166, offset: 0x7AA0E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC25loadImageAssetWithContextySbs5Int64V_So7UIImageCtFZTf4nnd_n', symObjAddr: 0x1C80, symBinAddr: 0x3E00, symSize: 0xD0 }
+  - { offsetInCU: 0x1263, offset: 0x7AB0B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dyys5Int64V_So7UIImageCS2ftFZTf4nnnnd_n', symObjAddr: 0x1D50, symBinAddr: 0x3ED0, symSize: 0x1B0 }
+  - { offsetInCU: 0x13D8, offset: 0x7AC80, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dy2dw2dhys5Int64V_So7UIImageCS4ftFZTf4nnnnnnd_n', symObjAddr: 0x1F00, symBinAddr: 0x4080, symSize: 0x1D0 }
+  - { offsetInCU: 0x156D, offset: 0x7AE15, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2sx2sy2sw2sh2dx2dy2dw2dhys5Int64V_So7UIImageCS8ftFZTf4nnnnnnnnnnd_n', symObjAddr: 0x20D0, symBinAddr: 0x4250, symSize: 0x200 }
+  - { offsetInCU: 0x1759, offset: 0x7B001, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZTf4nnnd_n', symObjAddr: 0x22D0, symBinAddr: 0x4450, symSize: 0x1D0 }
+  - { offsetInCU: 0x1823, offset: 0x7B0CB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZTf4nnnnd_n', symObjAddr: 0x2660, symBinAddr: 0x47E0, symSize: 0x200 }
+  - { offsetInCU: 0x1904, offset: 0x7B1AC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC32getPixelsPerInchForCurrentDeviceSSyFZTf4d_n', symObjAddr: 0x2860, symBinAddr: 0x49E0, symSize: 0x110 }
+  - { offsetInCU: 0x19AF, offset: 0x7B257, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgACIeyByy_SSSgADIeggg_TR', symObjAddr: 0xB30, symBinAddr: 0x2CB0, symSize: 0x70 }
+  - { offsetInCU: 0x19C7, offset: 0x7B26F, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgSo6NSDataCSgIeyByy_SSSgAFIeggg_TR', symObjAddr: 0xE30, symBinAddr: 0x2FB0, symSize: 0x50 }
+  - { offsetInCU: 0x1A34, offset: 0x7B2DC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCfETo', symObjAddr: 0x1710, symBinAddr: 0x3890, symSize: 0x10 }
+  - { offsetInCU: 0x1ABF, offset: 0x7B367, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCMa', symObjAddr: 0x2970, symBinAddr: 0x4AF0, symSize: 0x20 }
+  - { offsetInCU: 0x1AD3, offset: 0x7B37B, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgACIeyByy_SSSgADIeggg_TRTA', symObjAddr: 0x29B0, symBinAddr: 0x4B30, symSize: 0x10 }
+  - { offsetInCU: 0x1AF2, offset: 0x7B39A, size: 0x8, addend: 0x0, symName: '_$sSo7NSErrorCSg10ObjectiveC8ObjCBoolVIeyByy_ACSbIeggy_TRTA', symObjAddr: 0x29C0, symBinAddr: 0x4B40, symSize: 0x20 }
+  - { offsetInCU: 0x1B1B, offset: 0x7B3C3, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgSo6NSDataCSgIeyByy_SSSgAFIeggg_TRTA', symObjAddr: 0x29E0, symBinAddr: 0x4B60, symSize: 0x10 }
+  - { offsetInCU: 0x1B2F, offset: 0x7B3D7, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCMa', symObjAddr: 0x29F0, symBinAddr: 0x4B70, symSize: 0x30 }
+  - { offsetInCU: 0x1B43, offset: 0x7B3EB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZyyYbcfU_TA', symObjAddr: 0x2A70, symBinAddr: 0x4BF0, symSize: 0x40 }
+  - { offsetInCU: 0x1B57, offset: 0x7B3FF, size: 0x8, addend: 0x0, symName: _block_copy_helper, symObjAddr: 0x2AB0, symBinAddr: 0x4C30, symSize: 0x20 }
+  - { offsetInCU: 0x1B6B, offset: 0x7B413, size: 0x8, addend: 0x0, symName: _block_destroy_helper, symObjAddr: 0x2AD0, symBinAddr: 0x4C50, symSize: 0x10 }
+  - { offsetInCU: 0x1B7F, offset: 0x7B427, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZyyYbcfU_yyYbcfU0_TA', symObjAddr: 0x2B00, symBinAddr: 0x4C80, symSize: 0x40 }
+  - { offsetInCU: 0x1BB3, offset: 0x7B45B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZyyYbcfU_yyYbcfU0_TA', symObjAddr: 0x2BC0, symBinAddr: 0x4D40, symSize: 0x40 }
+  - { offsetInCU: 0x1BF1, offset: 0x7B499, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZyyYbcfU_yyYbcfU_TA', symObjAddr: 0x2C00, symBinAddr: 0x4D80, symSize: 0x20 }
+  - { offsetInCU: 0x1C25, offset: 0x7B4CD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZyyYbcfU_yyYbcfU_TA', symObjAddr: 0x2CB0, symBinAddr: 0x4E30, symSize: 0x40 }
+  - { offsetInCU: 0x1C59, offset: 0x7B501, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZyyYbcfU_yyYbcfU0_TA', symObjAddr: 0x2D20, symBinAddr: 0x4EA0, symSize: 0x30 }
+  - { offsetInCU: 0x1C95, offset: 0x7B53D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZyyYbcfU_TA', symObjAddr: 0x2DA0, symBinAddr: 0x4F20, symSize: 0x30 }
+  - { offsetInCU: 0x1CA9, offset: 0x7B551, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZyyYbcfU_yyYbcfU_TA', symObjAddr: 0x2DD0, symBinAddr: 0x4F50, symSize: 0x40 }
+  - { offsetInCU: 0x2176, offset: 0x7BA1E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC19getBytesFromUIImageySo13NSMutableDataCSo0G0CFZ', symObjAddr: 0x0, symBinAddr: 0x2180, symSize: 0x10 }
+  - { offsetInCU: 0x2191, offset: 0x7BA39, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x50, symBinAddr: 0x21D0, symSize: 0x10 }
+  - { offsetInCU: 0x21AC, offset: 0x7BA54, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC25loadImageAssetWithContextySbs5Int64V_So7UIImageCtFZ', symObjAddr: 0xC0, symBinAddr: 0x2240, symSize: 0x10 }
+  - { offsetInCU: 0x21CD, offset: 0x7BA75, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dyys5Int64V_So7UIImageCS2ftFZ', symObjAddr: 0x110, symBinAddr: 0x2290, symSize: 0x10 }
+  - { offsetInCU: 0x21E8, offset: 0x7BA90, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dy2dw2dhys5Int64V_So7UIImageCS4ftFZ', symObjAddr: 0x170, symBinAddr: 0x22F0, symSize: 0x10 }
+  - { offsetInCU: 0x2203, offset: 0x7BAAB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2sx2sy2sw2sh2dx2dy2dw2dhys5Int64V_So7UIImageCS8ftFZ', symObjAddr: 0x1E0, symBinAddr: 0x2360, symSize: 0x10 }
+  - { offsetInCU: 0x221E, offset: 0x7BAC6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23initWebGPUWithViewLayerys5Int64VAF_AFs6UInt32VAHtFZ', symObjAddr: 0x280, symBinAddr: 0x2400, symSize: 0x10 }
+  - { offsetInCU: 0x22AC, offset: 0x7BB54, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC18initWebGPUWithViewys5Int64VAF_AFs6UInt32VAHtFZ', symObjAddr: 0x2B0, symBinAddr: 0x2430, symSize: 0x10 }
+  - { offsetInCU: 0x232B, offset: 0x7BBD3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14initGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbtFZ', symObjAddr: 0x2E0, symBinAddr: 0x2460, symSize: 0x70 }
+  - { offsetInCU: 0x247D, offset: 0x7BD25, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC20initSharedGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbAFtFZ', symObjAddr: 0x3D0, symBinAddr: 0x2550, symSize: 0x70 }
+  - { offsetInCU: 0x25DB, offset: 0x7BE83, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC24initGLWithWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbtFZ', symObjAddr: 0x4C0, symBinAddr: 0x2640, symSize: 0x70 }
+  - { offsetInCU: 0x2739, offset: 0x7BFE1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC26initSharedGLWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbAFtFZ', symObjAddr: 0x5B0, symBinAddr: 0x2730, symSize: 0x80 }
+  - { offsetInCU: 0x28AD, offset: 0x7C155, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15resize2DContextyys5Int64V_S2ftFZ', symObjAddr: 0x6C0, symBinAddr: 0x2840, symSize: 0x10 }
+  - { offsetInCU: 0x291D, offset: 0x7C1C5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14flush2DContextyys5Int64VFZ', symObjAddr: 0x6E0, symBinAddr: 0x2860, symSize: 0x10 }
+  - { offsetInCU: 0x2960, offset: 0x7C208, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC7flushGLySbs5Int64VFZ', symObjAddr: 0x700, symBinAddr: 0x2880, symSize: 0x10 }
+  - { offsetInCU: 0x29A5, offset: 0x7C24D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9releaseGLyys5Int64VFZ', symObjAddr: 0x720, symBinAddr: 0x28A0, symSize: 0x10 }
+  - { offsetInCU: 0x29E8, offset: 0x7C290, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC12getGLPointerys5Int64VAFFZ', symObjAddr: 0x740, symBinAddr: 0x28C0, symSize: 0x10 }
+  - { offsetInCU: 0x2A2B, offset: 0x7C2D3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC16releaseGLPointeryys5Int64VFZ', symObjAddr: 0x760, symBinAddr: 0x28E0, symSize: 0x10 }
+  - { offsetInCU: 0x2A6E, offset: 0x7C316, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15create2DContextys5Int64VAF_s5Int32VAHSbSfA2HSfAHtFZ', symObjAddr: 0x780, symBinAddr: 0x2900, symSize: 0x10 }
+  - { offsetInCU: 0x2B54, offset: 0x7C3FC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23updateGLSurfaceWithViewyys5Int64V_s5Int32VAhFtFZ', symObjAddr: 0x7D0, symBinAddr: 0x2950, symSize: 0x10 }
+  - { offsetInCU: 0x2BD3, offset: 0x7C47B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC6test2Dyys5Int64VFZ', symObjAddr: 0x800, symBinAddr: 0x2980, symSize: 0x10 }
+  - { offsetInCU: 0x2C16, offset: 0x7C4BE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13testToDataURLySSs5Int64VFZ', symObjAddr: 0x820, symBinAddr: 0x29A0, symSize: 0x60 }
+  - { offsetInCU: 0x2CD7, offset: 0x7C57F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZ', symObjAddr: 0x8F0, symBinAddr: 0x2A70, symSize: 0x10 }
+  - { offsetInCU: 0x2CEB, offset: 0x7C593, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZyyYbcfU_', symObjAddr: 0x900, symBinAddr: 0x2A80, symSize: 0x190 }
+  - { offsetInCU: 0x2D8B, offset: 0x7C633, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZ', symObjAddr: 0xBA0, symBinAddr: 0x2D20, symSize: 0x30 }
+  - { offsetInCU: 0x2D9F, offset: 0x7C647, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZyyYbcfU_', symObjAddr: 0xBD0, symBinAddr: 0x2D50, symSize: 0x1C0 }
+  - { offsetInCU: 0x2E89, offset: 0x7C731, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZ', symObjAddr: 0xE80, symBinAddr: 0x3000, symSize: 0x30 }
+  - { offsetInCU: 0x2E9D, offset: 0x7C745, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZyyYbcfU_', symObjAddr: 0xEB0, symBinAddr: 0x3030, symSize: 0x240 }
+  - { offsetInCU: 0x2F51, offset: 0x7C7F9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZ', symObjAddr: 0x1190, symBinAddr: 0x3310, symSize: 0x10 }
+  - { offsetInCU: 0x2F65, offset: 0x7C80D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZyyYbcfU_', symObjAddr: 0x11A0, symBinAddr: 0x3320, symSize: 0x3A0 }
+  - { offsetInCU: 0x31FB, offset: 0x7CAA3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC32getPixelsPerInchForCurrentDeviceSSyFZ', symObjAddr: 0x1610, symBinAddr: 0x3790, symSize: 0x10 }
+  - { offsetInCU: 0x3216, offset: 0x7CABE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCACycfC', symObjAddr: 0x1660, symBinAddr: 0x37E0, symSize: 0x20 }
+  - { offsetInCU: 0x322A, offset: 0x7CAD2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCACycfc', symObjAddr: 0x1680, symBinAddr: 0x3800, symSize: 0x30 }
+  - { offsetInCU: 0x3260, offset: 0x7CB08, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCfD', symObjAddr: 0x16E0, symBinAddr: 0x3860, symSize: 0x30 }
+  - { offsetInCU: 0x4F, offset: 0x7CD40, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19shared_context_view33_508084857CA7D194CA72FEB80DD78002LLSo7GLKViewCvpZ', symObjAddr: 0x5C38, symBinAddr: 0x1363A20, symSize: 0x0 }
+  - { offsetInCU: 0x69, offset: 0x7CD5A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15_shared_context33_508084857CA7D194CA72FEB80DD78002LLs5Int64VvpZ', symObjAddr: 0x5C40, symBinAddr: 0x1363A28, symSize: 0x0 }
+  - { offsetInCU: 0x83, offset: 0x7CD74, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5storeSo19NSMutableDictionaryCvpZ', symObjAddr: 0x5C48, symBinAddr: 0x1363A30, symSize: 0x0 }
+  - { offsetInCU: 0x9D, offset: 0x7CD8E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5views33_508084857CA7D194CA72FEB80DD78002LLSo10NSMapTableCySo8NSStringCACGvpZ', symObjAddr: 0x5C50, symBinAddr: 0x1363A38, symSize: 0x0 }
+  - { offsetInCU: 0xAB, offset: 0x7CD9C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19shared_context_view33_508084857CA7D194CA72FEB80DD78002LL_WZ', symObjAddr: 0x0, symBinAddr: 0x5220, symSize: 0x60 }
+  - { offsetInCU: 0xF0, offset: 0x7CDE1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5store_WZ', symObjAddr: 0x60, symBinAddr: 0x5280, symSize: 0x30 }
+  - { offsetInCU: 0x135, offset: 0x7CE26, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5views33_508084857CA7D194CA72FEB80DD78002LL_WZ', symObjAddr: 0xD0, symBinAddr: 0x52F0, symSize: 0x40 }
+  - { offsetInCU: 0x187, offset: 0x7CE78, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC3ptrSvSgvgTo', symObjAddr: 0x1B0, symBinAddr: 0x53D0, symSize: 0x20 }
+  - { offsetInCU: 0x1DD, offset: 0x7CECE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC3ptrSvSgvsTo', symObjAddr: 0x1D0, symBinAddr: 0x53F0, symSize: 0x20 }
+  - { offsetInCU: 0x236, offset: 0x7CF27, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6mtlPtrSvSgvgTo', symObjAddr: 0x1F0, symBinAddr: 0x5410, symSize: 0x20 }
+  - { offsetInCU: 0x28C, offset: 0x7CF7D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6mtlPtrSvSgvsTo', symObjAddr: 0x210, symBinAddr: 0x5430, symSize: 0x20 }
+  - { offsetInCU: 0x2E5, offset: 0x7CFD6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvgTo', symObjAddr: 0x320, symBinAddr: 0x5540, symSize: 0x40 }
+  - { offsetInCU: 0x320, offset: 0x7D011, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvsTo', symObjAddr: 0x390, symBinAddr: 0x55B0, symSize: 0x30 }
+  - { offsetInCU: 0x3AF, offset: 0x7D0A0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8nativeGLs5Int64VvgTo', symObjAddr: 0x5D0, symBinAddr: 0x57F0, symSize: 0x40 }
+  - { offsetInCU: 0x405, offset: 0x7D0F6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8nativeGLs5Int64VvsTo', symObjAddr: 0x640, symBinAddr: 0x5860, symSize: 0x40 }
+  - { offsetInCU: 0x45E, offset: 0x7D14F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13nativeContexts5Int64VvgTo', symObjAddr: 0x680, symBinAddr: 0x58A0, symSize: 0x40 }
+  - { offsetInCU: 0x4B4, offset: 0x7D1A5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13nativeContexts5Int64VvsTo', symObjAddr: 0x6F0, symBinAddr: 0x5910, symSize: 0x40 }
+  - { offsetInCU: 0x50D, offset: 0x7D1FE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15native2DContexts5Int64VvgTo', symObjAddr: 0x730, symBinAddr: 0x5950, symSize: 0x20 }
+  - { offsetInCU: 0x563, offset: 0x7D254, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15native2DContexts5Int64VvsTo', symObjAddr: 0x750, symBinAddr: 0x5970, symSize: 0x20 }
+  - { offsetInCU: 0x5BC, offset: 0x7D2AD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7mtlViewSo7MTKViewCvgTo', symObjAddr: 0x770, symBinAddr: 0x5990, symSize: 0x20 }
+  - { offsetInCU: 0x614, offset: 0x7D305, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7mtlViewSo7MTKViewCvsTo', symObjAddr: 0x790, symBinAddr: 0x59B0, symSize: 0x30 }
+  - { offsetInCU: 0x66D, offset: 0x7D35E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7glkViewAA0A7GLKViewCvgTo', symObjAddr: 0x7C0, symBinAddr: 0x59E0, symSize: 0x20 }
+  - { offsetInCU: 0x6C5, offset: 0x7D3B6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7glkViewAA0A7GLKViewCvsTo', symObjAddr: 0x7E0, symBinAddr: 0x5A00, symSize: 0x30 }
+  - { offsetInCU: 0x71E, offset: 0x7D40F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC4is2DSbvgTo', symObjAddr: 0x810, symBinAddr: 0x5A30, symSize: 0x20 }
+  - { offsetInCU: 0x774, offset: 0x7D465, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC4is2DSbvsTo', symObjAddr: 0x830, symBinAddr: 0x5A50, symSize: 0x10 }
+  - { offsetInCU: 0x7CD, offset: 0x7D4BE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7isMetalSbvgTo', symObjAddr: 0x840, symBinAddr: 0x5A60, symSize: 0x20 }
+  - { offsetInCU: 0x823, offset: 0x7D514, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7isMetalSbvsTo', symObjAddr: 0x860, symBinAddr: 0x5A80, symSize: 0x10 }
+  - { offsetInCU: 0x866, offset: 0x7D557, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18drawingBufferWidthSivgTo', symObjAddr: 0x870, symBinAddr: 0x5A90, symSize: 0x30 }
+  - { offsetInCU: 0x898, offset: 0x7D589, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19drawingBufferHeightSivgTo', symObjAddr: 0x960, symBinAddr: 0x5B80, symSize: 0x30 }
+  - { offsetInCU: 0x8E0, offset: 0x7D5D1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5widthSfvgTo', symObjAddr: 0xA50, symBinAddr: 0x5C70, symSize: 0x30 }
+  - { offsetInCU: 0x948, offset: 0x7D639, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6heightSfvgTo', symObjAddr: 0xAB0, symBinAddr: 0x5CD0, symSize: 0x30 }
+  - { offsetInCU: 0x9E7, offset: 0x7D6D8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11initContextyySS_S4bs5Int32VS5btFTo', symObjAddr: 0xB20, symBinAddr: 0x5D40, symSize: 0xD0 }
+  - { offsetInCU: 0xA96, offset: 0x7D787, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17initWebGPUContextyys5Int64VFTo', symObjAddr: 0xDA0, symBinAddr: 0x5FC0, symSize: 0x30 }
+  - { offsetInCU: 0xB46, offset: 0x7D837, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC015initContextWithE10AttributesyySS_S4bs5Int32VS5btFTo', symObjAddr: 0x1760, symBinAddr: 0x6980, symSize: 0xD0 }
+  - { offsetInCU: 0xBB0, offset: 0x7D8A1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15create2DContextys5Int64VSb_S3bs5Int32VS5bAHtFTo', symObjAddr: 0x1A70, symBinAddr: 0x6C90, symSize: 0x90 }
+  - { offsetInCU: 0xBED, offset: 0x7D8DE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11forceLayoutyy12CoreGraphics7CGFloatV_AGtFTo', symObjAddr: 0x1BF0, symBinAddr: 0x6E10, symSize: 0x100 }
+  - { offsetInCU: 0xC6B, offset: 0x7D95C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8snapshotySo7UIImageCSgSbFTo', symObjAddr: 0x1DC0, symBinAddr: 0x6FE0, symSize: 0x40 }
+  - { offsetInCU: 0xC9E, offset: 0x7D98F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8rendererAA9NSCRenderCSgvgTo', symObjAddr: 0x1E00, symBinAddr: 0x7020, symSize: 0x20 }
+  - { offsetInCU: 0xCF8, offset: 0x7D9E9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8rendererAA9NSCRenderCSgvsTo', symObjAddr: 0x1E20, symBinAddr: 0x7040, symSize: 0x30 }
+  - { offsetInCU: 0xD53, offset: 0x7DA44, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6renderSbyFTo', symObjAddr: 0x1E90, symBinAddr: 0x70B0, symSize: 0x40 }
+  - { offsetInCU: 0xDE9, offset: 0x7DADA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13context2DTestyys5Int64VFTo', symObjAddr: 0x1F10, symBinAddr: 0x7130, symSize: 0x60 }
+  - { offsetInCU: 0xEAE, offset: 0x7DB9F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC22context2DTestToDataURLySSs5Int64VFTo', symObjAddr: 0x1FD0, symBinAddr: 0x71F0, symSize: 0xA0 }
+  - { offsetInCU: 0xF3B, offset: 0x7DC2C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC23enterBackgroundListeneryycSgvsTo', symObjAddr: 0x20C0, symBinAddr: 0x72E0, symSize: 0x70 }
+  - { offsetInCU: 0xF9D, offset: 0x7DC8E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC20becomeActiveListeneryycSgvsTo', symObjAddr: 0x21D0, symBinAddr: 0x73F0, symSize: 0x70 }
+  - { offsetInCU: 0xFFA, offset: 0x7DCEB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvgTo', symObjAddr: 0x2240, symBinAddr: 0x7460, symSize: 0xB0 }
+  - { offsetInCU: 0x104A, offset: 0x7DD3B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvsTo', symObjAddr: 0x23B0, symBinAddr: 0x75D0, symSize: 0x90 }
+  - { offsetInCU: 0x10DA, offset: 0x7DDCB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5coderACSgSo7NSCoderC_tcfcTo', symObjAddr: 0x3160, symBinAddr: 0x8380, symSize: 0x30 }
+  - { offsetInCU: 0x112F, offset: 0x7DE20, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5frameACSo6CGRectV_tcfcTo', symObjAddr: 0x3D20, symBinAddr: 0x8F40, symSize: 0x30 }
+  - { offsetInCU: 0x1162, offset: 0x7DE53, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvgTo', symObjAddr: 0x3D50, symBinAddr: 0x8F70, symSize: 0x20 }
+  - { offsetInCU: 0x11BA, offset: 0x7DEAB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvsTo', symObjAddr: 0x3D70, symBinAddr: 0x8F90, symSize: 0x30 }
+  - { offsetInCU: 0x1228, offset: 0x7DF19, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13readyListenerAA0cE0_pSgvgTo', symObjAddr: 0x3E20, symBinAddr: 0x9040, symSize: 0x30 }
+  - { offsetInCU: 0x1282, offset: 0x7DF73, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13readyListenerAA0cE0_pSgvsTo', symObjAddr: 0x3E50, symBinAddr: 0x9070, symSize: 0x30 }
+  - { offsetInCU: 0x12E2, offset: 0x7DFD3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11setListeneryyAA0cE0_pSgFTo', symObjAddr: 0x3EB0, symBinAddr: 0x90D0, symSize: 0x30 }
+  - { offsetInCU: 0x1426, offset: 0x7E117, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC14layoutSubviewsyyFTo', symObjAddr: 0x4290, symBinAddr: 0x94B0, symSize: 0x30 }
+  - { offsetInCU: 0x1459, offset: 0x7E14A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCfDTo', symObjAddr: 0x45B0, symBinAddr: 0x97D0, symSize: 0x20 }
+  - { offsetInCU: 0x1494, offset: 0x7E185, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC21getBoundingClientRectyySo6UIViewC_SvtFZTo', symObjAddr: 0x46A0, symBinAddr: 0x98C0, symSize: 0x30 }
+  - { offsetInCU: 0x14C7, offset: 0x7E1B8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC14shared_context33_508084857CA7D194CA72FEB80DD78002LLs5Int64VvgZTf4d_n', symObjAddr: 0x50D0, symBinAddr: 0xA2F0, symSize: 0x2A0 }
+  - { offsetInCU: 0x162F, offset: 0x7E320, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC21getBoundingClientRectyySo6UIViewC_SvtFZTf4nnd_n', symObjAddr: 0x5440, symBinAddr: 0xA660, symSize: 0xC0 }
+  - { offsetInCU: 0x184B, offset: 0x7E53C, size: 0x8, addend: 0x0, symName: '_$sIeg_IeyB_TR', symObjAddr: 0x2090, symBinAddr: 0x72B0, symSize: 0x30 }
+  - { offsetInCU: 0x1863, offset: 0x7E554, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_So8NSStringCABIeyByy_TR', symObjAddr: 0x2340, symBinAddr: 0x7560, symSize: 0x70 }
+  - { offsetInCU: 0x187B, offset: 0x7E56C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvpACTK', symObjAddr: 0x24A0, symBinAddr: 0x76C0, symSize: 0x90 }
+  - { offsetInCU: 0x18B3, offset: 0x7E5A4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvpACTk', symObjAddr: 0x2530, symBinAddr: 0x7750, symSize: 0xC0 }
+  - { offsetInCU: 0x18F3, offset: 0x7E5E4, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCytIegnnr_SSABIeggg_TR', symObjAddr: 0x25F0, symBinAddr: 0x7810, symSize: 0x70 }
+  - { offsetInCU: 0x19A3, offset: 0x7E694, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCfETo', symObjAddr: 0x45D0, symBinAddr: 0x97F0, symSize: 0xC0 }
+  - { offsetInCU: 0x19D3, offset: 0x7E6C4, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_SgWOy', symObjAddr: 0x46D0, symBinAddr: 0x98F0, symSize: 0x20 }
+  - { offsetInCU: 0x19E7, offset: 0x7E6D8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCMa', symObjAddr: 0x46F0, symBinAddr: 0x9910, symSize: 0x20 }
+  - { offsetInCU: 0x19FB, offset: 0x7E6EC, size: 0x8, addend: 0x0, symName: '_$ss29getContiguousArrayStorageType3fors01_bcD0CyxGmxm_tlFSo18NSLayoutConstraintC_Tgm5', symObjAddr: 0x4710, symBinAddr: 0x9930, symSize: 0x60 }
+  - { offsetInCU: 0x1C02, offset: 0x7E8F3, size: 0x8, addend: 0x0, symName: ___swift_instantiateConcreteTypeFromMangledName, symObjAddr: 0x5370, symBinAddr: 0xA590, symSize: 0x40 }
+  - { offsetInCU: 0x1C16, offset: 0x7E907, size: 0x8, addend: 0x0, symName: '_$sypSgWOh', symObjAddr: 0x53B0, symBinAddr: 0xA5D0, symSize: 0x30 }
+  - { offsetInCU: 0x1C2A, offset: 0x7E91B, size: 0x8, addend: 0x0, symName: ___swift_project_boxed_opaque_existential_0, symObjAddr: 0x53E0, symBinAddr: 0xA600, symSize: 0x30 }
+  - { offsetInCU: 0x1C3E, offset: 0x7E92F, size: 0x8, addend: 0x0, symName: ___swift_destroy_boxed_opaque_existential_0, symObjAddr: 0x5410, symBinAddr: 0xA630, symSize: 0x30 }
+  - { offsetInCU: 0x1C5D, offset: 0x7E94E, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSo19UIGestureRecognizerCIeyByy_SSADIeggg_TRTA', symObjAddr: 0x59A0, symBinAddr: 0xABC0, symSize: 0x40 }
+  - { offsetInCU: 0x1C86, offset: 0x7E977, size: 0x8, addend: 0x0, symName: _block_copy_helper, symObjAddr: 0x59E0, symBinAddr: 0xAC00, symSize: 0x20 }
+  - { offsetInCU: 0x1C9A, offset: 0x7E98B, size: 0x8, addend: 0x0, symName: _block_destroy_helper, symObjAddr: 0x5A00, symBinAddr: 0xAC20, symSize: 0x10 }
+  - { offsetInCU: 0x1CAE, offset: 0x7E99F, size: 0x8, addend: 0x0, symName: '_$sIeg_SgWOe', symObjAddr: 0x5A10, symBinAddr: 0xAC30, symSize: 0x20 }
+  - { offsetInCU: 0x1CCD, offset: 0x7E9BE, size: 0x8, addend: 0x0, symName: '_$sIeyB_Ieg_TRTA', symObjAddr: 0x5A30, symBinAddr: 0xAC50, symSize: 0x10 }
+  - { offsetInCU: 0x1CF6, offset: 0x7E9E7, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCytIegnnr_SSABIeggg_TRTA', symObjAddr: 0x5A60, symBinAddr: 0xAC80, symSize: 0x20 }
+  - { offsetInCU: 0x1D15, offset: 0x7EA06, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_SSABytIegnnr_TRTA', symObjAddr: 0x5A80, symBinAddr: 0xACA0, symSize: 0x30 }
+  - { offsetInCU: 0x1D3E, offset: 0x7EA2F, size: 0x8, addend: 0x0, symName: '_$sypWOb', symObjAddr: 0x5AB0, symBinAddr: 0xACD0, symSize: 0x20 }
+  - { offsetInCU: 0x1D52, offset: 0x7EA43, size: 0x8, addend: 0x0, symName: '_$sypWOc', symObjAddr: 0x5B00, symBinAddr: 0xAD20, symSize: 0x30 }
+  - { offsetInCU: 0x1FD7, offset: 0x7ECC8, size: 0x8, addend: 0x0, symName: '_$sSD17dictionaryLiteralSDyxq_Gx_q_td_tcfCSS_ypTgm5Tf4g_n', symObjAddr: 0x4FE0, symBinAddr: 0xA200, symSize: 0xF0 }
+  - { offsetInCU: 0x2469, offset: 0x7F15A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvg', symObjAddr: 0x360, symBinAddr: 0x5580, symSize: 0x30 }
+  - { offsetInCU: 0x249A, offset: 0x7F18B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvs', symObjAddr: 0x3C0, symBinAddr: 0x55E0, symSize: 0xE0 }
+  - { offsetInCU: 0x24E4, offset: 0x7F1D5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvM', symObjAddr: 0x4A0, symBinAddr: 0x56C0, symSize: 0x50 }
+  - { offsetInCU: 0x2507, offset: 0x7F1F8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvM.resume.0', symObjAddr: 0x4F0, symBinAddr: 0x5710, symSize: 0xE0 }
+  - { offsetInCU: 0x2548, offset: 0x7F239, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8nativeGLs5Int64Vvg', symObjAddr: 0x610, symBinAddr: 0x5830, symSize: 0x30 }
+  - { offsetInCU: 0x259E, offset: 0x7F28F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13nativeContexts5Int64Vvg', symObjAddr: 0x6C0, symBinAddr: 0x58E0, symSize: 0x30 }
+  - { offsetInCU: 0x270A, offset: 0x7F3FB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18drawingBufferWidthSivg', symObjAddr: 0x8A0, symBinAddr: 0x5AC0, symSize: 0xC0 }
+  - { offsetInCU: 0x282F, offset: 0x7F520, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19drawingBufferHeightSivg', symObjAddr: 0x990, symBinAddr: 0x5BB0, symSize: 0xC0 }
+  - { offsetInCU: 0x2975, offset: 0x7F666, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5widthSfvg', symObjAddr: 0xA80, symBinAddr: 0x5CA0, symSize: 0x30 }
+  - { offsetInCU: 0x29BB, offset: 0x7F6AC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6heightSfvg', symObjAddr: 0xAE0, symBinAddr: 0x5D00, symSize: 0x30 }
+  - { offsetInCU: 0x29ED, offset: 0x7F6DE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11initContextyySS_S4bs5Int32VS5btF', symObjAddr: 0xB10, symBinAddr: 0x5D30, symSize: 0x10 }
+  - { offsetInCU: 0x2B6A, offset: 0x7F85B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17initWebGPUContextyys5Int64VF', symObjAddr: 0xBF0, symBinAddr: 0x5E10, symSize: 0x1B0 }
+  - { offsetInCU: 0x2F4D, offset: 0x7FC3E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC015initContextWithE10AttributesyySS_S4bs5Int32VS5btF', symObjAddr: 0xDD0, symBinAddr: 0x5FF0, symSize: 0x990 }
+  - { offsetInCU: 0x36DB, offset: 0x803CC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15create2DContextys5Int64VSb_S3bs5Int32VS5bAHtF', symObjAddr: 0x1830, symBinAddr: 0x6A50, symSize: 0x240 }
+  - { offsetInCU: 0x3B67, offset: 0x80858, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11forceLayoutyy12CoreGraphics7CGFloatV_AGtF', symObjAddr: 0x1B00, symBinAddr: 0x6D20, symSize: 0xF0 }
+  - { offsetInCU: 0x3BF6, offset: 0x808E7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8snapshotySo7UIImageCSgSbF', symObjAddr: 0x1CF0, symBinAddr: 0x6F10, symSize: 0xD0 }
+  - { offsetInCU: 0x3D4F, offset: 0x80A40, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6renderSbyF', symObjAddr: 0x1E50, symBinAddr: 0x7070, symSize: 0x40 }
+  - { offsetInCU: 0x3DD3, offset: 0x80AC4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13context2DTestyys5Int64VF', symObjAddr: 0x1ED0, symBinAddr: 0x70F0, symSize: 0x40 }
+  - { offsetInCU: 0x3EF2, offset: 0x80BE3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC22context2DTestToDataURLySSs5Int64VF', symObjAddr: 0x1F70, symBinAddr: 0x7190, symSize: 0x60 }
+  - { offsetInCU: 0x3FE8, offset: 0x80CD9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvg', symObjAddr: 0x22F0, symBinAddr: 0x7510, symSize: 0x50 }
+  - { offsetInCU: 0x4032, offset: 0x80D23, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvs', symObjAddr: 0x2440, symBinAddr: 0x7660, symSize: 0x60 }
+  - { offsetInCU: 0x4059, offset: 0x80D4A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvM', symObjAddr: 0x2660, symBinAddr: 0x7880, symSize: 0x40 }
+  - { offsetInCU: 0x407F, offset: 0x80D70, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvM.resume.0', symObjAddr: 0x26A0, symBinAddr: 0x78C0, symSize: 0x10 }
+  - { offsetInCU: 0x4141, offset: 0x80E32, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5coderACSgSo7NSCoderC_tcfc', symObjAddr: 0x26B0, symBinAddr: 0x78D0, symSize: 0xAB0 }
+  - { offsetInCU: 0x4366, offset: 0x81057, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5frameACSo6CGRectV_tcfC', symObjAddr: 0x3190, symBinAddr: 0x83B0, symSize: 0x80 }
+  - { offsetInCU: 0x438F, offset: 0x81080, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5frameACSo6CGRectV_tcfc', symObjAddr: 0x3210, symBinAddr: 0x8430, symSize: 0xB10 }
+  - { offsetInCU: 0x45D5, offset: 0x812C6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvW', symObjAddr: 0x3DA0, symBinAddr: 0x8FC0, symSize: 0x80 }
+  - { offsetInCU: 0x46CB, offset: 0x813BC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11setListeneryyAA0cE0_pSgF', symObjAddr: 0x3E80, symBinAddr: 0x90A0, symSize: 0x30 }
+  - { offsetInCU: 0x4767, offset: 0x81458, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6resize33_508084857CA7D194CA72FEB80DD78002LLyyF', symObjAddr: 0x3EE0, symBinAddr: 0x9100, symSize: 0x110 }
+  - { offsetInCU: 0x49B8, offset: 0x816A9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC14layoutSubviewsyyF', symObjAddr: 0x3FF0, symBinAddr: 0x9210, symSize: 0x2A0 }
+  - { offsetInCU: 0x4C14, offset: 0x81905, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCfD', symObjAddr: 0x42C0, symBinAddr: 0x94E0, symSize: 0x2F0 }
+  - { offsetInCU: 0x4CA2, offset: 0x81993, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC21getBoundingClientRectyySo6UIViewC_SvtFZ', symObjAddr: 0x4690, symBinAddr: 0x98B0, symSize: 0x10 }
+  - { offsetInCU: 0x4CCA, offset: 0x819BB, size: 0x8, addend: 0x0, symName: '_$ss22__RawDictionaryStorageC4findys10_HashTableV6BucketV6bucket_Sb5foundtxSHRzlFSS_Tg5', symObjAddr: 0x4770, symBinAddr: 0x9990, symSize: 0x60 }
+  - { offsetInCU: 0x4D24, offset: 0x81A15, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV7_insert2at3key5valueys10_HashTableV6BucketV_xnq_ntFSS_ypTg5', symObjAddr: 0x47D0, symBinAddr: 0x99F0, symSize: 0x60 }
+  - { offsetInCU: 0x4D90, offset: 0x81A81, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV12mutatingFind_8isUniques10_HashTableV6BucketV6bucket_Sb5foundtx_SbtFSS_ypTg5', symObjAddr: 0x4830, symBinAddr: 0x9A50, symSize: 0xB0 }
+  - { offsetInCU: 0x4DCD, offset: 0x81ABE, size: 0x8, addend: 0x0, symName: '_$ss22__RawDictionaryStorageC4find_9hashValues10_HashTableV6BucketV6bucket_Sb5foundtx_SitSHRzlFSS_Tg5', symObjAddr: 0x48E0, symBinAddr: 0x9B00, symSize: 0xE0 }
+  - { offsetInCU: 0x4E38, offset: 0x81B29, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV4copyyyFSS_ypTg5', symObjAddr: 0x49C0, symBinAddr: 0x9BE0, symSize: 0x260 }
+  - { offsetInCU: 0x4EE0, offset: 0x81BD1, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV20_copyOrMoveAndResize8capacity12moveElementsySi_SbtFSS_ypTg5', symObjAddr: 0x4C20, symBinAddr: 0x9E40, symSize: 0x3C0 }
+  - { offsetInCU: 0x27, offset: 0x81E25, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative7GLUtilsCfD', symObjAddr: 0x0, symBinAddr: 0xAE00, symSize: 0x20 }
+  - { offsetInCU: 0x62, offset: 0x81E60, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative7GLUtilsCMa', symObjAddr: 0x20, symBinAddr: 0xAE20, symSize: 0x14 }
+  - { offsetInCU: 0x1AF, offset: 0x81FAD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative7GLUtilsCfD', symObjAddr: 0x0, symBinAddr: 0xAE00, symSize: 0x20 }
+  - { offsetInCU: 0x65, offset: 0x8203A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8mPrograms6UInt32VvgTo', symObjAddr: 0x0, symBinAddr: 0xAE40, symSize: 0x10 }
+  - { offsetInCU: 0xBB, offset: 0x82090, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8mPrograms6UInt32VvsTo', symObjAddr: 0x10, symBinAddr: 0xAE50, symSize: 0x10 }
+  - { offsetInCU: 0x114, offset: 0x820E9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3rbos6UInt32VvgTo', symObjAddr: 0x20, symBinAddr: 0xAE60, symSize: 0x40 }
+  - { offsetInCU: 0x16A, offset: 0x8213F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3rbos6UInt32VvsTo', symObjAddr: 0x60, symBinAddr: 0xAEA0, symSize: 0x40 }
+  - { offsetInCU: 0x1C3, offset: 0x82198, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3fbos6UInt32VvgTo', symObjAddr: 0xA0, symBinAddr: 0xAEE0, symSize: 0x40 }
+  - { offsetInCU: 0x219, offset: 0x821EE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3fbos6UInt32VvsTo', symObjAddr: 0xE0, symBinAddr: 0xAF20, symSize: 0x40 }
+  - { offsetInCU: 0x272, offset: 0x82247, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC5widthSivgTo', symObjAddr: 0x120, symBinAddr: 0xAF60, symSize: 0x20 }
+  - { offsetInCU: 0x2C8, offset: 0x8229D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC5widthSivsTo', symObjAddr: 0x140, symBinAddr: 0xAF80, symSize: 0x20 }
+  - { offsetInCU: 0x321, offset: 0x822F6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC6heightSivgTo', symObjAddr: 0x160, symBinAddr: 0xAFA0, symSize: 0x20 }
+  - { offsetInCU: 0x377, offset: 0x8234C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC6heightSivsTo', symObjAddr: 0x180, symBinAddr: 0xAFC0, symSize: 0x20 }
+  - { offsetInCU: 0x3D0, offset: 0x823A5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC2abs6UInt32VvgTo', symObjAddr: 0x1A0, symBinAddr: 0xAFE0, symSize: 0x40 }
+  - { offsetInCU: 0x426, offset: 0x823FB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC2abs6UInt32VvsTo', symObjAddr: 0x1E0, symBinAddr: 0xB020, symSize: 0x40 }
+  - { offsetInCU: 0x47F, offset: 0x82454, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3poss5Int32VvgTo', symObjAddr: 0x220, symBinAddr: 0xB060, symSize: 0x10 }
+  - { offsetInCU: 0x4D5, offset: 0x824AA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3poss5Int32VvsTo', symObjAddr: 0x230, symBinAddr: 0xB070, symSize: 0x10 }
+  - { offsetInCU: 0x52E, offset: 0x82503, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10samplerPoss5Int32VvgTo', symObjAddr: 0x240, symBinAddr: 0xB080, symSize: 0x10 }
+  - { offsetInCU: 0x584, offset: 0x82559, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10samplerPoss5Int32VvsTo', symObjAddr: 0x250, symBinAddr: 0xB090, symSize: 0x10 }
+  - { offsetInCU: 0x5DD, offset: 0x825B2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9vextexBufSaySfGvgTo', symObjAddr: 0x260, symBinAddr: 0xB0A0, symSize: 0x40 }
+  - { offsetInCU: 0x633, offset: 0x82608, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9vextexBufSaySfGvsTo', symObjAddr: 0x2A0, symBinAddr: 0xB0E0, symSize: 0x40 }
+  - { offsetInCU: 0x676, offset: 0x8264B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13SIZE_OF_FLOATSivgZTo', symObjAddr: 0x2E0, symBinAddr: 0xB120, symSize: 0x10 }
+  - { offsetInCU: 0x692, offset: 0x82667, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13VERTEX_SHADERSSvgZTo', symObjAddr: 0x2F0, symBinAddr: 0xB130, symSize: 0x30 }
+  - { offsetInCU: 0x6C4, offset: 0x82699, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7surfaceSo9IOSurfaceCSgvgTo', symObjAddr: 0x320, symBinAddr: 0xB160, symSize: 0x20 }
+  - { offsetInCU: 0x71C, offset: 0x826F1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7surfaceSo9IOSurfaceCSgvsTo', symObjAddr: 0x340, symBinAddr: 0xB180, symSize: 0x30 }
+  - { offsetInCU: 0x775, offset: 0x8274A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8pixelBufs9UnmanagedVySo11CVBufferRefaGSgvgTo', symObjAddr: 0x490, symBinAddr: 0xB2D0, symSize: 0x20 }
+  - { offsetInCU: 0x7CB, offset: 0x827A0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8pixelBufs9UnmanagedVySo11CVBufferRefaGSgvsTo', symObjAddr: 0x4B0, symBinAddr: 0xB2F0, symSize: 0x20 }
+  - { offsetInCU: 0x83A, offset: 0x8280F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCACycfcTo', symObjAddr: 0x680, symBinAddr: 0xB480, symSize: 0x20 }
+  - { offsetInCU: 0x86C, offset: 0x82841, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7destroyyyFTo', symObjAddr: 0x7E0, symBinAddr: 0xB5E0, symSize: 0x30 }
+  - { offsetInCU: 0x8C4, offset: 0x82899, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10texImage2Dyys5Int32V_A4fA9NSCCanvasCAHSbtFTo', symObjAddr: 0x830, symBinAddr: 0xB630, symSize: 0x80 }
+  - { offsetInCU: 0x928, offset: 0x828FD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9drawFrame6buffer5width6height14internalFormat6format10flipYWebGLySo11CVBufferRefa_S2is5Int32VANSbtFTo', symObjAddr: 0x8B0, symBinAddr: 0xB6B0, symSize: 0x80 }
+  - { offsetInCU: 0x9CA, offset: 0x8299F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13createSurfaceyyFTo', symObjAddr: 0xCE0, symBinAddr: 0xBAE0, symSize: 0x30 }
+  - { offsetInCU: 0xAB4, offset: 0x82A89, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCMa', symObjAddr: 0x660, symBinAddr: 0xB460, symSize: 0x20 }
+  - { offsetInCU: 0xB33, offset: 0x82B08, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCfETo', symObjAddr: 0xD40, symBinAddr: 0xBB40, symSize: 0x60 }
+  - { offsetInCU: 0x1271, offset: 0x83246, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCACycfC', symObjAddr: 0x4D0, symBinAddr: 0xB310, symSize: 0x20 }
+  - { offsetInCU: 0x128B, offset: 0x83260, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCACycfc', symObjAddr: 0x4F0, symBinAddr: 0xB330, symSize: 0x130 }
+  - { offsetInCU: 0x12BB, offset: 0x83290, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7destroyyyF', symObjAddr: 0x6A0, symBinAddr: 0xB4A0, symSize: 0x140 }
+  - { offsetInCU: 0x1474, offset: 0x83449, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10texImage2Dyys5Int32V_A4fA9NSCCanvasCAHSbtF', symObjAddr: 0x810, symBinAddr: 0xB610, symSize: 0x20 }
+  - { offsetInCU: 0x1525, offset: 0x834FA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13createSurfaceyyF', symObjAddr: 0x930, symBinAddr: 0xB730, symSize: 0x3B0 }
+  - { offsetInCU: 0x18BB, offset: 0x83890, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCfD', symObjAddr: 0xD10, symBinAddr: 0xBB10, symSize: 0x30 }
+  - { offsetInCU: 0x19B4, offset: 0x83989, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10texImage2Dyys5Int32V_A4fA9NSCCanvasCAHSbtFTf4ddnndnndn_n', symObjAddr: 0xDA0, symBinAddr: 0xBBA0, symSize: 0x720 }
+  - { offsetInCU: 0x231C, offset: 0x842F1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9drawFrame6buffer5width6height14internalFormat6format10flipYWebGLySo11CVBufferRefa_S2is5Int32VANSbtFTf4nnnnndn_n', symObjAddr: 0x1520, symBinAddr: 0xC320, symSize: 0x7EC }
+  - { offsetInCU: 0x10C, offset: 0x84E9A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC6target6actionAEypSg_10ObjectiveC8SelectorVSgtcfcTo', symObjAddr: 0x1120, symBinAddr: 0xDBF0, symSize: 0x60 }
+  - { offsetInCU: 0x19C, offset: 0x84F2A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerCfETo', symObjAddr: 0x11A0, symBinAddr: 0xDC70, symSize: 0x20 }
+  - { offsetInCU: 0x1CB, offset: 0x84F59, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC6handleyySo19UIGestureRecognizerCFTo', symObjAddr: 0x11C0, symBinAddr: 0xDC90, symSize: 0x10 }
+  - { offsetInCU: 0x368, offset: 0x850F6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerCACycfcTo', symObjAddr: 0x1A40, symBinAddr: 0xE510, symSize: 0x30 }
+  - { offsetInCU: 0x5E4, offset: 0x85372, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerCfETo', symObjAddr: 0x1AC0, symBinAddr: 0xE590, symSize: 0x60 }
+  - { offsetInCU: 0x613, offset: 0x853A1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerCMa', symObjAddr: 0x1B20, symBinAddr: 0xE5F0, symSize: 0x20 }
+  - { offsetInCU: 0x627, offset: 0x853B5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerCMa', symObjAddr: 0x1B40, symBinAddr: 0xE610, symSize: 0x20 }
+  - { offsetInCU: 0x63B, offset: 0x853C9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwCP', symObjAddr: 0x1B60, symBinAddr: 0xE630, symSize: 0x30 }
+  - { offsetInCU: 0x64F, offset: 0x853DD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwxx', symObjAddr: 0x1B90, symBinAddr: 0xE660, symSize: 0x10 }
+  - { offsetInCU: 0x663, offset: 0x853F1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwcp', symObjAddr: 0x1BA0, symBinAddr: 0xE670, symSize: 0x30 }
+  - { offsetInCU: 0x677, offset: 0x85405, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwca', symObjAddr: 0x1BD0, symBinAddr: 0xE6A0, symSize: 0x50 }
+  - { offsetInCU: 0x68B, offset: 0x85419, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwta', symObjAddr: 0x1C40, symBinAddr: 0xE6F0, symSize: 0x40 }
+  - { offsetInCU: 0x69F, offset: 0x8542D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwet', symObjAddr: 0x1C80, symBinAddr: 0xE730, symSize: 0x40 }
+  - { offsetInCU: 0x6B3, offset: 0x85441, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwst', symObjAddr: 0x1CC0, symBinAddr: 0xE770, symSize: 0x50 }
+  - { offsetInCU: 0x6C7, offset: 0x85455, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVMa', symObjAddr: 0x1D10, symBinAddr: 0xE7C0, symSize: 0x10 }
+  - { offsetInCU: 0x6DB, offset: 0x85469, size: 0x8, addend: 0x0, symName: '_$sypSgWOc', symObjAddr: 0x1D20, symBinAddr: 0xE7D0, symSize: 0x40 }
+  - { offsetInCU: 0x6EF, offset: 0x8547D, size: 0x8, addend: 0x0, symName: '_$sSo7UITouchCSo8NSObjectCSH10ObjectiveCWl', symObjAddr: 0x1E30, symBinAddr: 0xE810, symSize: 0x50 }
+  - { offsetInCU: 0x703, offset: 0x85491, size: 0x8, addend: 0x0, symName: '_$sSh8IteratorV8_VariantOyx__GSHRzlWOe', symObjAddr: 0x1E80, symBinAddr: 0xE860, symSize: 0x20 }
+  - { offsetInCU: 0x761, offset: 0x854EF, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_SgWOe', symObjAddr: 0x21A0, symBinAddr: 0xEB80, symSize: 0x14 }
+  - { offsetInCU: 0xCB4, offset: 0x85A42, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC12touchesBegan_4withyShySo7UITouchCG_So7UIEventCtF', symObjAddr: 0x0, symBinAddr: 0xCB10, symSize: 0x630 }
+  - { offsetInCU: 0xF39, offset: 0x85CC7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC12touchesMoved_4withyShySo7UITouchCG_So7UIEventCtF', symObjAddr: 0x650, symBinAddr: 0xD160, symSize: 0xE0 }
+  - { offsetInCU: 0xFB8, offset: 0x85D46, size: 0x8, addend: 0x0, symName: '_$sSa6remove2atxSi_tF12CanvasNative15NSCTouchHandlerC7PointerV_Tg5', symObjAddr: 0x800, symBinAddr: 0xD2F0, symSize: 0xB0 }
+  - { offsetInCU: 0x102A, offset: 0x85DB8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC6target6actionAEypSg_10ObjectiveC8SelectorVSgtcfc', symObjAddr: 0x1030, symBinAddr: 0xDB00, symSize: 0xF0 }
+  - { offsetInCU: 0x1179, offset: 0x85F07, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC6onMove33_044DDF836BDB3B89B481C6F58BB6EF6BLLyySo19UIGestureRecognizerC_ShySo7UITouchCGSgtF', symObjAddr: 0x1590, symBinAddr: 0xE060, symSize: 0x4B0 }
+  - { offsetInCU: 0x18C2, offset: 0x86650, size: 0x8, addend: 0x0, symName: '_$ss12_ArrayBufferV20_consumeAndCreateNewAByxGyF12CanvasNative15NSCTouchHandlerC7PointerV_Tg5', symObjAddr: 0x1EA0, symBinAddr: 0xE880, symSize: 0x20 }
+  - { offsetInCU: 0x195A, offset: 0x866E8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC6canvasAcA9NSCCanvasC_tcfcTf4gn_n', symObjAddr: 0x1EC0, symBinAddr: 0xE8A0, symSize: 0x1F0 }
+  - { offsetInCU: 0x27, offset: 0x868B1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC14FAILED_TO_LOADSSvgZTo', symObjAddr: 0x0, symBinAddr: 0xEBA0, symSize: 0x30 }
+  - { offsetInCU: 0x4B, offset: 0x868D5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queueSo012OS_dispatch_E0CvpZ', symObjAddr: 0x2A0, symBinAddr: 0x1363D48, symSize: 0x0 }
+  - { offsetInCU: 0x65, offset: 0x868EF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC14FAILED_TO_LOADSSvgZTo', symObjAddr: 0x0, symBinAddr: 0xEBA0, symSize: 0x30 }
+  - { offsetInCU: 0x98, offset: 0x86922, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queueSo012OS_dispatch_E0CvgZTo', symObjAddr: 0x160, symBinAddr: 0xED00, symSize: 0x30 }
+  - { offsetInCU: 0x104, offset: 0x8698E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCACycfcTo', symObjAddr: 0x200, symBinAddr: 0xEDA0, symSize: 0x30 }
+  - { offsetInCU: 0x158, offset: 0x869E2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queue_WZ', symObjAddr: 0x30, symBinAddr: 0xEBD0, symSize: 0xF0 }
+  - { offsetInCU: 0x183, offset: 0x86A0D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCMa', symObjAddr: 0x1E0, symBinAddr: 0xED80, symSize: 0x20 }
+  - { offsetInCU: 0x197, offset: 0x86A21, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCfETo', symObjAddr: 0x260, symBinAddr: 0xEE00, symSize: 0x10 }
+  - { offsetInCU: 0x1C2, offset: 0x86A4C, size: 0x8, addend: 0x0, symName: '_$sSo17OS_dispatch_queueCMa', symObjAddr: 0x270, symBinAddr: 0xEE10, symSize: 0x2F }
+  - { offsetInCU: 0x34A, offset: 0x86BD4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queueSo012OS_dispatch_E0CvgZ', symObjAddr: 0x120, symBinAddr: 0xECC0, symSize: 0x40 }
+  - { offsetInCU: 0x38A, offset: 0x86C14, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCACycfC', symObjAddr: 0x190, symBinAddr: 0xED30, symSize: 0x20 }
+  - { offsetInCU: 0x39E, offset: 0x86C28, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCACycfc', symObjAddr: 0x1B0, symBinAddr: 0xED50, symSize: 0x30 }
+  - { offsetInCU: 0x3DA, offset: 0x86C64, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCfD', symObjAddr: 0x230, symBinAddr: 0xEDD0, symSize: 0x30 }
+  - { offsetInCU: 0x2B, offset: 0x86CB2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC18createTextureCacheSo017CVOpenGLESTextureF3RefaSgyFZ', symObjAddr: 0x0, symBinAddr: 0xEE40, symSize: 0xA0 }
+  - { offsetInCU: 0x66, offset: 0x86CED, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC18createTextureCacheSo017CVOpenGLESTextureF3RefaSgyFZTo', symObjAddr: 0xA0, symBinAddr: 0xEEE0, symSize: 0xA0 }
+  - { offsetInCU: 0xF9, offset: 0x86D80, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11createImageySo11CVBufferRefaSgSo022CVOpenGLESTextureCacheG0a_AFSo012CFDictionaryG0aSgs6UInt32Vs5Int32VA2p2NSitFZTo', symObjAddr: 0x1D0, symBinAddr: 0xF010, symSize: 0x100 }
+  - { offsetInCU: 0x1AD, offset: 0x86E34, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11setupRenderAA9NSCRenderCyFZTo', symObjAddr: 0x300, symBinAddr: 0xF140, symSize: 0x30 }
+  - { offsetInCU: 0x22D, offset: 0x86EB4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC9drawFrameyySo8AVPlayerC_So0F15ItemVideoOutputCSo6CGSizeVAA9NSCRenderCs5Int32VANSbtFZTo', symObjAddr: 0x340, symBinAddr: 0xF180, symSize: 0x90 }
+  - { offsetInCU: 0x2A6, offset: 0x86F2D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11writeToFileyySo6NSDataC_SStKFZTo', symObjAddr: 0x4E0, symBinAddr: 0xF320, symSize: 0x140 }
+  - { offsetInCU: 0x345, offset: 0x86FCC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCACycfcTo', symObjAddr: 0x670, symBinAddr: 0xF4B0, symSize: 0x30 }
+  - { offsetInCU: 0x398, offset: 0x8701F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC9drawFrameyySo8AVPlayerC_So0F15ItemVideoOutputCSo6CGSizeVAA9NSCRenderCs5Int32VANSbtFZTf4nnnnnndd_n', symObjAddr: 0x6D0, symBinAddr: 0xF510, symSize: 0x170 }
+  - { offsetInCU: 0x50B, offset: 0x87192, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC7getFile33_F00B23A4165DD6ABFCD23C8811C7DF43LLyS2SKFZTf4nd_g', symObjAddr: 0x840, symBinAddr: 0xF680, symSize: 0x310 }
+  - { offsetInCU: 0x5EA, offset: 0x87271, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCMa', symObjAddr: 0xB50, symBinAddr: 0xF990, symSize: 0x20 }
+  - { offsetInCU: 0x5FE, offset: 0x87285, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOAEs5ErrorAAWl', symObjAddr: 0xB70, symBinAddr: 0xF9B0, symSize: 0x30 }
+  - { offsetInCU: 0x612, offset: 0x87299, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwCP', symObjAddr: 0xBA0, symBinAddr: 0xF9E0, symSize: 0x30 }
+  - { offsetInCU: 0x626, offset: 0x872AD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwxx', symObjAddr: 0xBD0, symBinAddr: 0xFA10, symSize: 0x10 }
+  - { offsetInCU: 0x63A, offset: 0x872C1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwca', symObjAddr: 0xBE0, symBinAddr: 0xFA20, symSize: 0x40 }
+  - { offsetInCU: 0x64E, offset: 0x872D5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwta', symObjAddr: 0xC30, symBinAddr: 0xFA60, symSize: 0x30 }
+  - { offsetInCU: 0x662, offset: 0x872E9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwet', symObjAddr: 0xC60, symBinAddr: 0xFA90, symSize: 0x40 }
+  - { offsetInCU: 0x676, offset: 0x872FD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwst', symObjAddr: 0xCA0, symBinAddr: 0xFAD0, symSize: 0x40 }
+  - { offsetInCU: 0x68A, offset: 0x87311, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwug', symObjAddr: 0xCE0, symBinAddr: 0xFB10, symSize: 0x10 }
+  - { offsetInCU: 0x69E, offset: 0x87325, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwup', symObjAddr: 0xCF0, symBinAddr: 0xFB20, symSize: 0x10 }
+  - { offsetInCU: 0x6B2, offset: 0x87339, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwui', symObjAddr: 0xD00, symBinAddr: 0xFB30, symSize: 0x10 }
+  - { offsetInCU: 0x6C6, offset: 0x8734D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOMa', symObjAddr: 0xD10, symBinAddr: 0xFB40, symSize: 0x10 }
+  - { offsetInCU: 0x74E, offset: 0x873D5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP7_domainSSvgTW', symObjAddr: 0x3D0, symBinAddr: 0xF210, symSize: 0x10 }
+  - { offsetInCU: 0x76A, offset: 0x873F1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP5_codeSivgTW', symObjAddr: 0x3E0, symBinAddr: 0xF220, symSize: 0x10 }
+  - { offsetInCU: 0x786, offset: 0x8740D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP9_userInfoyXlSgvgTW', symObjAddr: 0x3F0, symBinAddr: 0xF230, symSize: 0x10 }
+  - { offsetInCU: 0x7A2, offset: 0x87429, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP19_getEmbeddedNSErroryXlSgyFTW', symObjAddr: 0x400, symBinAddr: 0xF240, symSize: 0x10 }
+  - { offsetInCU: 0xA56, offset: 0x876DD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC18createTextureCacheSo017CVOpenGLESTextureF3RefaSgyFZ', symObjAddr: 0x0, symBinAddr: 0xEE40, symSize: 0xA0 }
+  - { offsetInCU: 0xAEC, offset: 0x87773, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11createImageySo11CVBufferRefaSgSo022CVOpenGLESTextureCacheG0a_AFSo012CFDictionaryG0aSgs6UInt32Vs5Int32VA2p2NSitFZ', symObjAddr: 0x140, symBinAddr: 0xEF80, symSize: 0x90 }
+  - { offsetInCU: 0xC71, offset: 0x878F8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11setupRenderAA9NSCRenderCyFZ', symObjAddr: 0x2D0, symBinAddr: 0xF110, symSize: 0x30 }
+  - { offsetInCU: 0xCBB, offset: 0x87942, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC9drawFrameyySo8AVPlayerC_So0F15ItemVideoOutputCSo6CGSizeVAA9NSCRenderCs5Int32VANSbtFZ', symObjAddr: 0x330, symBinAddr: 0xF170, symSize: 0x10 }
+  - { offsetInCU: 0xCDD, offset: 0x87964, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11writeToFileyySo6NSDataC_SStKFZ', symObjAddr: 0x410, symBinAddr: 0xF250, symSize: 0xD0 }
+  - { offsetInCU: 0xD8D, offset: 0x87A14, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCACycfC', symObjAddr: 0x620, symBinAddr: 0xF460, symSize: 0x20 }
+  - { offsetInCU: 0xDA1, offset: 0x87A28, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCACycfc', symObjAddr: 0x640, symBinAddr: 0xF480, symSize: 0x30 }
+  - { offsetInCU: 0xDD7, offset: 0x87A5E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCfD', symObjAddr: 0x6A0, symBinAddr: 0xF4E0, symSize: 0x30 }
+  - { offsetInCU: 0x27, offset: 0x87B7E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x0, symBinAddr: 0xFB60, symSize: 0x10 }
+  - { offsetInCU: 0x71, offset: 0x87BC8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZTo', symObjAddr: 0x10, symBinAddr: 0xFB70, symSize: 0x60 }
+  - { offsetInCU: 0xF6, offset: 0x87C4D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS2ftFZTo', symObjAddr: 0x80, symBinAddr: 0xFBE0, symSize: 0x50 }
+  - { offsetInCU: 0x193, offset: 0x87CEA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS4ftFZTo', symObjAddr: 0xE0, symBinAddr: 0xFC40, symSize: 0x60 }
+  - { offsetInCU: 0x25C, offset: 0x87DB3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS8ftFZTo', symObjAddr: 0x150, symBinAddr: 0xFCB0, symSize: 0x90 }
+  - { offsetInCU: 0x339, offset: 0x87E90, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCACycfcTo', symObjAddr: 0x230, symBinAddr: 0xFD90, symSize: 0x30 }
+  - { offsetInCU: 0x38D, offset: 0x87EE4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCMa', symObjAddr: 0x290, symBinAddr: 0xFDF0, symSize: 0x14 }
+  - { offsetInCU: 0x4FD, offset: 0x88054, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x0, symBinAddr: 0xFB60, symSize: 0x10 }
+  - { offsetInCU: 0x5A0, offset: 0x880F7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS2ftFZ', symObjAddr: 0x70, symBinAddr: 0xFBD0, symSize: 0x10 }
+  - { offsetInCU: 0x640, offset: 0x88197, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS4ftFZ', symObjAddr: 0xD0, symBinAddr: 0xFC30, symSize: 0x10 }
+  - { offsetInCU: 0x703, offset: 0x8825A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS8ftFZ', symObjAddr: 0x140, symBinAddr: 0xFCA0, symSize: 0x10 }
+  - { offsetInCU: 0x80F, offset: 0x88366, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCACycfC', symObjAddr: 0x1E0, symBinAddr: 0xFD40, symSize: 0x20 }
+  - { offsetInCU: 0x823, offset: 0x8837A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCACycfc', symObjAddr: 0x200, symBinAddr: 0xFD60, symSize: 0x30 }
+  - { offsetInCU: 0x859, offset: 0x883B0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCfD', symObjAddr: 0x260, symBinAddr: 0xFDC0, symSize: 0x30 }
+  - { offsetInCU: 0x27, offset: 0x883FA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC10texImage2Dyys5Int64V_s5Int32VA4HSpys5UInt8VGSuSo6CGSizeVSbtFZ', symObjAddr: 0x0, symBinAddr: 0xFE10, symSize: 0x30 }
+  - { offsetInCU: 0xA9, offset: 0x8847C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC10texImage2Dyys5Int64V_s5Int32VA4HSpys5UInt8VGSuSo6CGSizeVSbtFZTo', symObjAddr: 0x30, symBinAddr: 0xFE40, symSize: 0x50 }
+  - { offsetInCU: 0x1A6, offset: 0x88579, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC13texSubImage2Dyys5Int64V_s5Int32VA5HSpys5UInt8VGSuSo6CGSizeVSbtFZTo', symObjAddr: 0xC0, symBinAddr: 0xFED0, symSize: 0x50 }
+  - { offsetInCU: 0x289, offset: 0x8865C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCACycfcTo', symObjAddr: 0x180, symBinAddr: 0xFF90, symSize: 0x30 }
+  - { offsetInCU: 0x2DD, offset: 0x886B0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCMa', symObjAddr: 0x160, symBinAddr: 0xFF70, symSize: 0x20 }
+  - { offsetInCU: 0x487, offset: 0x8885A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC10texImage2Dyys5Int64V_s5Int32VA4HSpys5UInt8VGSuSo6CGSizeVSbtFZ', symObjAddr: 0x0, symBinAddr: 0xFE10, symSize: 0x30 }
+  - { offsetInCU: 0x5DD, offset: 0x889B0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC13texSubImage2Dyys5Int64V_s5Int32VA5HSpys5UInt8VGSuSo6CGSizeVSbtFZ', symObjAddr: 0x80, symBinAddr: 0xFE90, symSize: 0x40 }
+  - { offsetInCU: 0x725, offset: 0x88AF8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCACycfC', symObjAddr: 0x110, symBinAddr: 0xFF20, symSize: 0x20 }
+  - { offsetInCU: 0x739, offset: 0x88B0C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCACycfc', symObjAddr: 0x130, symBinAddr: 0xFF40, symSize: 0x30 }
+  - { offsetInCU: 0x76F, offset: 0x88B42, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCfD', symObjAddr: 0x1B0, symBinAddr: 0xFFC0, symSize: 0x2B }
+  - { offsetInCU: 0x61, offset: 0x88BC6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7isDirtySbvgTo', symObjAddr: 0x10, symBinAddr: 0x10000, symSize: 0x20 }
+  - { offsetInCU: 0xB7, offset: 0x88C1C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7isDirtySbvsTo', symObjAddr: 0x30, symBinAddr: 0x10020, symSize: 0x10 }
+  - { offsetInCU: 0x110, offset: 0x88C75, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC6canvasAA9NSCCanvasCSgvgTo', symObjAddr: 0x40, symBinAddr: 0x10030, symSize: 0x40 }
+  - { offsetInCU: 0x168, offset: 0x88CCD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC6canvasAA9NSCCanvasCSgvsTo', symObjAddr: 0xC0, symBinAddr: 0x100B0, symSize: 0x40 }
+  - { offsetInCU: 0x1C3, offset: 0x88D28, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC3fbos6UInt32VvgTo', symObjAddr: 0x100, symBinAddr: 0x100F0, symSize: 0x10 }
+  - { offsetInCU: 0x219, offset: 0x88D7E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC3fbos6UInt32VvsTo', symObjAddr: 0x110, symBinAddr: 0x10100, symSize: 0x10 }
+  - { offsetInCU: 0x272, offset: 0x88DD7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCACycfcTo', symObjAddr: 0x1C0, symBinAddr: 0x101B0, symSize: 0x80 }
+  - { offsetInCU: 0x2CA, offset: 0x88E2F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frameACSo6CGRectV_tcfcTo', symObjAddr: 0x300, symBinAddr: 0x102F0, symSize: 0xA0 }
+  - { offsetInCU: 0x32C, offset: 0x88E91, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5coderACSgSo7NSCoderC_tcfcTo', symObjAddr: 0x470, symBinAddr: 0x10460, symSize: 0x30 }
+  - { offsetInCU: 0x35E, offset: 0x88EC3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC12bindDrawableyyFTo', symObjAddr: 0x520, symBinAddr: 0x10490, symSize: 0xA0 }
+  - { offsetInCU: 0x3DF, offset: 0x88F44, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC14deleteDrawableyyFTo', symObjAddr: 0x600, symBinAddr: 0x10530, symSize: 0x60 }
+  - { offsetInCU: 0x44F, offset: 0x88FB4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7glkView_6drawInySo0C0C_So6CGRectVtFTo', symObjAddr: 0x670, symBinAddr: 0x105A0, symSize: 0x50 }
+  - { offsetInCU: 0x4C1, offset: 0x89026, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frame7contextACSo6CGRectV_So11EAGLContextCtcfcTo', symObjAddr: 0x780, symBinAddr: 0x106B0, symSize: 0x30 }
+  - { offsetInCU: 0x535, offset: 0x8909A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCMa', symObjAddr: 0x1A0, symBinAddr: 0x10190, symSize: 0x20 }
+  - { offsetInCU: 0x55F, offset: 0x890C4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCfETo', symObjAddr: 0x7D0, symBinAddr: 0x10700, symSize: 0x20 }
+  - { offsetInCU: 0x65D, offset: 0x891C2, size: 0x8, addend: 0x0, symName: '_$sSo7GLKViewC12CanvasNativeE16snapshotWithDatayy10Foundation0F0VFTo', symObjAddr: 0xAF0, symBinAddr: 0x10A20, symSize: 0x80 }
+  - { offsetInCU: 0x69B, offset: 0x89200, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC7isDirtySbvgTo', symObjAddr: 0xB70, symBinAddr: 0x10AA0, symSize: 0x20 }
+  - { offsetInCU: 0x6F1, offset: 0x89256, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC7isDirtySbvsTo', symObjAddr: 0xB90, symBinAddr: 0x10AC0, symSize: 0x10 }
+  - { offsetInCU: 0x74A, offset: 0x892AF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC8rendererAA9NSCCanvasCSgvgTo', symObjAddr: 0xBA0, symBinAddr: 0x10AD0, symSize: 0x20 }
+  - { offsetInCU: 0x7A2, offset: 0x89307, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC8rendererAA9NSCCanvasCSgvsTo', symObjAddr: 0xBC0, symBinAddr: 0x10AF0, symSize: 0x20 }
+  - { offsetInCU: 0x7FD, offset: 0x89362, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvgTo', symObjAddr: 0xBE0, symBinAddr: 0x10B10, symSize: 0x40 }
+  - { offsetInCU: 0x853, offset: 0x893B8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvsTo', symObjAddr: 0xC50, symBinAddr: 0x10B80, symSize: 0x40 }
+  - { offsetInCU: 0x8E6, offset: 0x8944B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCACycfcTo', symObjAddr: 0xDC0, symBinAddr: 0x10CF0, symSize: 0x80 }
+  - { offsetInCU: 0x93E, offset: 0x894A3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5frameACSo6CGRectV_tcfcTo', symObjAddr: 0xF90, symBinAddr: 0x10EC0, symSize: 0xA0 }
+  - { offsetInCU: 0x9A0, offset: 0x89505, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5coderACSgSo7NSCoderC_tcfcTo', symObjAddr: 0x10E0, symBinAddr: 0x11010, symSize: 0x30 }
+  - { offsetInCU: 0x9D2, offset: 0x89537, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC11deviceScaleSfyFTo', symObjAddr: 0x1110, symBinAddr: 0x11040, symSize: 0xB0 }
+  - { offsetInCU: 0xA53, offset: 0x895B8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC4drawyySo6CGRectVFTo', symObjAddr: 0x11D0, symBinAddr: 0x110F0, symSize: 0x30 }
+  - { offsetInCU: 0xAB1, offset: 0x89616, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCfETo', symObjAddr: 0x1250, symBinAddr: 0x11170, symSize: 0x20 }
+  - { offsetInCU: 0xC63, offset: 0x897C8, size: 0x8, addend: 0x0, symName: '_$ss22_ContiguousArrayBufferV19_uninitializedCount15minimumCapacityAByxGSi_SitcfC12CanvasNative15NSCTouchHandlerC7PointerV_Tgm5', symObjAddr: 0x1470, symBinAddr: 0x112E0, symSize: 0x80 }
+  - { offsetInCU: 0xCE6, offset: 0x8984B, size: 0x8, addend: 0x0, symName: '_$ss22_ContiguousArrayBufferV19_uninitializedCount15minimumCapacityAByxGSi_SitcfCs5UInt8V_Tgm5', symObjAddr: 0x1570, symBinAddr: 0x11360, symSize: 0x70 }
+  - { offsetInCU: 0xD6A, offset: 0x898CF, size: 0x8, addend: 0x0, symName: '_$s10Foundation4DataV15_RepresentationOWOy', symObjAddr: 0x1750, symBinAddr: 0x11540, symSize: 0x40 }
+  - { offsetInCU: 0xD7E, offset: 0x898E3, size: 0x8, addend: 0x0, symName: '_$s10Foundation4DataV15_RepresentationOWOe', symObjAddr: 0x1790, symBinAddr: 0x11580, symSize: 0x40 }
+  - { offsetInCU: 0xD92, offset: 0x898F7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCMa', symObjAddr: 0x17D0, symBinAddr: 0x115C0, symSize: 0x20 }
+  - { offsetInCU: 0xE6C, offset: 0x899D1, size: 0x8, addend: 0x0, symName: '_$sSaySayxGqd__c7ElementQyd__RszSTRd__lufCs5UInt8V_10Foundation4DataVTgm5Tf4g_n', symObjAddr: 0x1650, symBinAddr: 0x11440, symSize: 0x100 }
+  - { offsetInCU: 0x112B, offset: 0x89C90, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC6canvasAA9NSCCanvasCSgvg', symObjAddr: 0x80, symBinAddr: 0x10070, symSize: 0x40 }
+  - { offsetInCU: 0x11A8, offset: 0x89D0D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCACycfc', symObjAddr: 0x120, symBinAddr: 0x10110, symSize: 0x80 }
+  - { offsetInCU: 0x11EF, offset: 0x89D54, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frameACSo6CGRectV_tcfc', symObjAddr: 0x240, symBinAddr: 0x10230, symSize: 0xC0 }
+  - { offsetInCU: 0x1251, offset: 0x89DB6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5coderACSgSo7NSCoderC_tcfc', symObjAddr: 0x3A0, symBinAddr: 0x10390, symSize: 0xD0 }
+  - { offsetInCU: 0x12DA, offset: 0x89E3F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7glkView_6drawInySo0C0C_So6CGRectVtF', symObjAddr: 0x660, symBinAddr: 0x10590, symSize: 0x10 }
+  - { offsetInCU: 0x12FB, offset: 0x89E60, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frame7contextACSo6CGRectV_So11EAGLContextCtcfC', symObjAddr: 0x6C0, symBinAddr: 0x105F0, symSize: 0x90 }
+  - { offsetInCU: 0x130F, offset: 0x89E74, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frame7contextACSo6CGRectV_So11EAGLContextCtcfc', symObjAddr: 0x750, symBinAddr: 0x10680, symSize: 0x30 }
+  - { offsetInCU: 0x1428, offset: 0x89F8D, size: 0x8, addend: 0x0, symName: '_$sSo7GLKViewC12CanvasNativeE16snapshotWithDatayy10Foundation0F0VF', symObjAddr: 0x7F0, symBinAddr: 0x10720, symSize: 0x300 }
+  - { offsetInCU: 0x17D2, offset: 0x8A337, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvg', symObjAddr: 0xC20, symBinAddr: 0x10B50, symSize: 0x30 }
+  - { offsetInCU: 0x180F, offset: 0x8A374, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvs', symObjAddr: 0xC90, symBinAddr: 0x10BC0, symSize: 0x40 }
+  - { offsetInCU: 0x1836, offset: 0x8A39B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvM', symObjAddr: 0xCD0, symBinAddr: 0x10C00, symSize: 0x40 }
+  - { offsetInCU: 0x185B, offset: 0x8A3C0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvM.resume.0', symObjAddr: 0xD10, symBinAddr: 0x10C40, symSize: 0x10 }
+  - { offsetInCU: 0x1882, offset: 0x8A3E7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCACycfC', symObjAddr: 0xD20, symBinAddr: 0x10C50, symSize: 0x20 }
+  - { offsetInCU: 0x1896, offset: 0x8A3FB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCACycfc', symObjAddr: 0xD40, symBinAddr: 0x10C70, symSize: 0x80 }
+  - { offsetInCU: 0x18DD, offset: 0x8A442, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5frameACSo6CGRectV_tcfc', symObjAddr: 0xED0, symBinAddr: 0x10E00, symSize: 0xC0 }
+  - { offsetInCU: 0x193A, offset: 0x8A49F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5coderACSgSo7NSCoderC_tcfc', symObjAddr: 0x1030, symBinAddr: 0x10F60, symSize: 0xB0 }
+  - { offsetInCU: 0x19D6, offset: 0x8A53B, size: 0x8, addend: 0x0, symName: '_$ss12_ArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtF12CanvasNative15NSCTouchHandlerC7PointerV_Tg5', symObjAddr: 0x1270, symBinAddr: 0x11190, symSize: 0xB0 }
+  - { offsetInCU: 0x1AB8, offset: 0x8A61D, size: 0x8, addend: 0x0, symName: '_$ss12_ArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtFs5UInt8V_Tg5', symObjAddr: 0x13D0, symBinAddr: 0x11240, symSize: 0xA0 }
+  - { offsetInCU: 0x1BC4, offset: 0x8A729, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7glkView_6drawInySo0C0C_So6CGRectVtFTf4ddn_n', symObjAddr: 0x15E0, symBinAddr: 0x113D0, symSize: 0x70 }
+  - { offsetInCU: 0x1CBF, offset: 0x8A824, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC4drawyySo6CGRectVFTf4dn_n', symObjAddr: 0x17F0, symBinAddr: 0x115E0, symSize: 0x410 }
+  - { offsetInCU: 0x4F, offset: 0x8AC3C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC5queue33_7ED578B0ED4B2B6F6887A622A7B49AA3LLSo012OS_dispatch_E0CvpZ', symObjAddr: 0x980, symBinAddr: 0x1363E90, symSize: 0x0 }
+  - { offsetInCU: 0x5D, offset: 0x8AC4A, size: 0x8, addend: 0x0, symName: '_$sIegh_IeyBh_TR', symObjAddr: 0x0, symBinAddr: 0x11BE0, symSize: 0x30 }
+  - { offsetInCU: 0x75, offset: 0x8AC62, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC5queue33_7ED578B0ED4B2B6F6887A622A7B49AA3LL_WZ', symObjAddr: 0x30, symBinAddr: 0x11C10, symSize: 0xF0 }
+  - { offsetInCU: 0xBC, offset: 0x8ACA9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF4SyncySbs5Int64V_So7UIImageCtFZTo', symObjAddr: 0x130, symBinAddr: 0x11D10, symSize: 0x40 }
+  - { offsetInCU: 0x130, offset: 0x8AD1D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZTo', symObjAddr: 0x3C0, symBinAddr: 0x11FA0, symSize: 0x80 }
+  - { offsetInCU: 0x18F, offset: 0x8AD7C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCACycfcTo', symObjAddr: 0x490, symBinAddr: 0x12070, symSize: 0x30 }
+  - { offsetInCU: 0x1E2, offset: 0x8ADCF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZTf4nnnd_n', symObjAddr: 0x500, symBinAddr: 0x120E0, symSize: 0x200 }
+  - { offsetInCU: 0x261, offset: 0x8AE4E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCfETo', symObjAddr: 0x4F0, symBinAddr: 0x120D0, symSize: 0x10 }
+  - { offsetInCU: 0x29D, offset: 0x8AE8A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCMa', symObjAddr: 0x700, symBinAddr: 0x122E0, symSize: 0x20 }
+  - { offsetInCU: 0x2BC, offset: 0x8AEA9, size: 0x8, addend: 0x0, symName: '_$s10ObjectiveC8ObjCBoolVIeyBy_SbIegy_TRTA', symObjAddr: 0x740, symBinAddr: 0x12320, symSize: 0x20 }
+  - { offsetInCU: 0x2E5, offset: 0x8AED2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_TA', symObjAddr: 0x790, symBinAddr: 0x12370, symSize: 0x20 }
+  - { offsetInCU: 0x2F9, offset: 0x8AEE6, size: 0x8, addend: 0x0, symName: _block_copy_helper, symObjAddr: 0x7B0, symBinAddr: 0x12390, symSize: 0x20 }
+  - { offsetInCU: 0x30D, offset: 0x8AEFA, size: 0x8, addend: 0x0, symName: _block_destroy_helper, symObjAddr: 0x7D0, symBinAddr: 0x123B0, symSize: 0x10 }
+  - { offsetInCU: 0x321, offset: 0x8AF0E, size: 0x8, addend: 0x0, symName: '_$sSay8Dispatch0A13WorkItemFlagsVGMa', symObjAddr: 0x850, symBinAddr: 0x123F0, symSize: 0x50 }
+  - { offsetInCU: 0x335, offset: 0x8AF22, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_yyScMYccfU0_TA', symObjAddr: 0x8D0, symBinAddr: 0x12440, symSize: 0x20 }
+  - { offsetInCU: 0x369, offset: 0x8AF56, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_yyScMYccfU_TA', symObjAddr: 0x910, symBinAddr: 0x12480, symSize: 0x20 }
+  - { offsetInCU: 0x4FE, offset: 0x8B0EB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF4SyncySbs5Int64V_So7UIImageCtFZ', symObjAddr: 0x120, symBinAddr: 0x11D00, symSize: 0x10 }
+  - { offsetInCU: 0x58B, offset: 0x8B178, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZ', symObjAddr: 0x170, symBinAddr: 0x11D50, symSize: 0x10 }
+  - { offsetInCU: 0x59F, offset: 0x8B18C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_', symObjAddr: 0x180, symBinAddr: 0x11D60, symSize: 0x240 }
+  - { offsetInCU: 0x678, offset: 0x8B265, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCACycfC', symObjAddr: 0x440, symBinAddr: 0x12020, symSize: 0x20 }
+  - { offsetInCU: 0x68C, offset: 0x8B279, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCACycfc', symObjAddr: 0x460, symBinAddr: 0x12040, symSize: 0x30 }
+  - { offsetInCU: 0x6C2, offset: 0x8B2AF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCfD', symObjAddr: 0x4C0, symBinAddr: 0x120A0, symSize: 0x30 }
+  - { offsetInCU: 0x27, offset: 0x8B355, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfC', symObjAddr: 0x0, symBinAddr: 0x124F0, symSize: 0x20 }
+  - { offsetInCU: 0x77, offset: 0x8B3A5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfcTo', symObjAddr: 0x70, symBinAddr: 0x12560, symSize: 0x30 }
+  - { offsetInCU: 0xCB, offset: 0x8B3F9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCMa', symObjAddr: 0x50, symBinAddr: 0x12540, symSize: 0x20 }
+  - { offsetInCU: 0x216, offset: 0x8B544, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfC', symObjAddr: 0x0, symBinAddr: 0x124F0, symSize: 0x20 }
+  - { offsetInCU: 0x22A, offset: 0x8B558, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfc', symObjAddr: 0x20, symBinAddr: 0x12510, symSize: 0x30 }
+  - { offsetInCU: 0x266, offset: 0x8B594, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCfD', symObjAddr: 0xA0, symBinAddr: 0x12590, symSize: 0x2B }
+  - { offsetInCU: 0x26, offset: 0x8B5DD, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_frombytes_vartime, symObjAddr: 0x0, symBinAddr: 0x3C38E0, symSize: 0x3990 }
+  - { offsetInCU: 0x40, offset: 0x8B5F7, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_k25519Precomp, symObjAddr: 0xEEC0, symBinAddr: 0xB5CAE0, symSize: 0x0 }
+  - { offsetInCU: 0x92, offset: 0x8B649, size: 0x8, addend: 0x0, symName: _d, symObjAddr: 0x14EC0, symBinAddr: 0xB62AE0, symSize: 0x0 }
+  - { offsetInCU: 0xF6, offset: 0x8B6AD, size: 0x8, addend: 0x0, symName: _sqrtm1, symObjAddr: 0x14EE8, symBinAddr: 0xB62B08, symSize: 0x0 }
+  - { offsetInCU: 0x10C, offset: 0x8B6C3, size: 0x8, addend: 0x0, symName: _d2, symObjAddr: 0x152F0, symBinAddr: 0xB62F10, symSize: 0x0 }
+  - { offsetInCU: 0x123, offset: 0x8B6DA, size: 0x8, addend: 0x0, symName: _Bi, symObjAddr: 0x14F30, symBinAddr: 0xB62B50, symSize: 0x0 }
+  - { offsetInCU: 0xE22, offset: 0x8C3D9, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_frombytes_vartime, symObjAddr: 0x0, symBinAddr: 0x3C38E0, symSize: 0x3990 }
+  - { offsetInCU: 0x4DAE, offset: 0x90365, size: 0x8, addend: 0x0, symName: _fe_mul_impl, symObjAddr: 0xE6E0, symBinAddr: 0x3D1FC0, symSize: 0x3E0 }
+  - { offsetInCU: 0x4FF1, offset: 0x905A8, size: 0x8, addend: 0x0, symName: _fe_tobytes, symObjAddr: 0x7C20, symBinAddr: 0x3CB500, symSize: 0x270 }
+  - { offsetInCU: 0x582C, offset: 0x90DE3, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_scalarmult_base, symObjAddr: 0x3990, symBinAddr: 0x3C7270, symSize: 0xA10 }
+  - { offsetInCU: 0x684B, offset: 0x91E02, size: 0x8, addend: 0x0, symName: _table_select, symObjAddr: 0x43A0, symBinAddr: 0x3C7C80, symSize: 0xA10 }
+  - { offsetInCU: 0x6EE9, offset: 0x924A0, size: 0x8, addend: 0x0, symName: _ge_madd, symObjAddr: 0x4DB0, symBinAddr: 0x3C8690, symSize: 0x2B0 }
+  - { offsetInCU: 0x74BC, offset: 0x92A73, size: 0x8, addend: 0x0, symName: _ge_p2_dbl, symObjAddr: 0x5060, symBinAddr: 0x3C8940, symSize: 0xCD0 }
+  - { offsetInCU: 0x83FE, offset: 0x939B5, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_sc_reduce, symObjAddr: 0x5D30, symBinAddr: 0x3C9610, symSize: 0xB40 }
+  - { offsetInCU: 0x8F67, offset: 0x9451E, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_scalar_mult_generic_masked, symObjAddr: 0x6870, symBinAddr: 0x3CA150, symSize: 0x13B0 }
+  - { offsetInCU: 0xA567, offset: 0x95B1E, size: 0x8, addend: 0x0, symName: _fe_loose_invert, symObjAddr: 0x7FF0, symBinAddr: 0x3CB8D0, symSize: 0x2A30 }
+  - { offsetInCU: 0xDC6D, offset: 0x99224, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_public_from_private_generic_masked, symObjAddr: 0x7E90, symBinAddr: 0x3CB770, symSize: 0x160 }
+  - { offsetInCU: 0xDEE7, offset: 0x9949E, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_invert, symObjAddr: 0xAA20, symBinAddr: 0x3CE300, symSize: 0x30 }
+  - { offsetInCU: 0xDFDC, offset: 0x99593, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_isnegative, symObjAddr: 0xAA50, symBinAddr: 0x3CE330, symSize: 0x50 }
+  - { offsetInCU: 0xE051, offset: 0x99608, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_mul_ttt, symObjAddr: 0xAAA0, symBinAddr: 0x3CE380, symSize: 0x10 }
+  - { offsetInCU: 0xE0EC, offset: 0x996A3, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_neg, symObjAddr: 0xAAB0, symBinAddr: 0x3CE390, symSize: 0xB0 }
+  - { offsetInCU: 0xE217, offset: 0x997CE, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_tobytes, symObjAddr: 0xAB60, symBinAddr: 0x3CE440, symSize: 0x10 }
+  - { offsetInCU: 0xE4E9, offset: 0x99AA0, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_double_scalarmult_vartime, symObjAddr: 0xAB70, symBinAddr: 0x3CE450, symSize: 0x21A0 }
+  - { offsetInCU: 0x1118F, offset: 0x9C746, size: 0x8, addend: 0x0, symName: _x25519_ge_add, symObjAddr: 0xEAC0, symBinAddr: 0x3D23A0, symSize: 0x2D1 }
+  - { offsetInCU: 0x117CF, offset: 0x9CD86, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_sc_mask, symObjAddr: 0xCD10, symBinAddr: 0x3D05F0, symSize: 0x20 }
+  - { offsetInCU: 0x11C6C, offset: 0x9D223, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_sc_muladd, symObjAddr: 0xCD30, symBinAddr: 0x3D0610, symSize: 0x19B0 }
+  - { offsetInCU: 0x26, offset: 0x9E2D3, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_nohw_set_encrypt_key, symObjAddr: 0x0, symBinAddr: 0x3D2680, symSize: 0x800 }
+  - { offsetInCU: 0x41, offset: 0x9E2EE, size: 0x8, addend: 0x0, symName: _aes_nohw_rcon, symObjAddr: 0x1B10, symBinAddr: 0xB62FF0, symSize: 0x0 }
+  - { offsetInCU: 0x484, offset: 0x9E731, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_nohw_set_encrypt_key, symObjAddr: 0x0, symBinAddr: 0x3D2680, symSize: 0x800 }
+  - { offsetInCU: 0x1B2B, offset: 0x9FDD8, size: 0x8, addend: 0x0, symName: _aes_nohw_sub_bytes, symObjAddr: 0x15F0, symBinAddr: 0x3D3C70, symSize: 0x300 }
+  - { offsetInCU: 0x32EE, offset: 0xA159B, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_nohw_encrypt, symObjAddr: 0x800, symBinAddr: 0x3D2E80, symSize: 0x80 }
+  - { offsetInCU: 0x33DC, offset: 0xA1689, size: 0x8, addend: 0x0, symName: _aes_nohw_expand_round_keys, symObjAddr: 0x880, symBinAddr: 0x3D2F00, symSize: 0x1A0 }
+  - { offsetInCU: 0x386D, offset: 0xA1B1A, size: 0x8, addend: 0x0, symName: _aes_nohw_to_batch, symObjAddr: 0xA20, symBinAddr: 0x3D30A0, symSize: 0x420 }
+  - { offsetInCU: 0x3D7D, offset: 0xA202A, size: 0x8, addend: 0x0, symName: _aes_nohw_encrypt_batch, symObjAddr: 0xE40, symBinAddr: 0x3D34C0, symSize: 0x380 }
+  - { offsetInCU: 0x424C, offset: 0xA24F9, size: 0x8, addend: 0x0, symName: _aes_nohw_from_batch, symObjAddr: 0x11C0, symBinAddr: 0x3D3840, symSize: 0x250 }
+  - { offsetInCU: 0x498D, offset: 0xA2C3A, size: 0x8, addend: 0x0, symName: _aes_nohw_shift_rows, symObjAddr: 0x18F0, symBinAddr: 0x3D3F70, symSize: 0x149 }
+  - { offsetInCU: 0x4BF9, offset: 0xA2EA6, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_nohw_ctr32_encrypt_blocks, symObjAddr: 0x1410, symBinAddr: 0x3D3A90, symSize: 0x1E0 }
+  - { offsetInCU: 0x26, offset: 0xA32C7, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_from_montgomery_in_place, symObjAddr: 0x0, symBinAddr: 0x3D40C0, symSize: 0x2DC }
+  - { offsetInCU: 0x1D2, offset: 0xA3473, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_from_montgomery_in_place, symObjAddr: 0x0, symBinAddr: 0x3D40C0, symSize: 0x2DC }
+  - { offsetInCU: 0x26, offset: 0xA36CC, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_neg_inv_mod_r_u64, symObjAddr: 0x0, symBinAddr: 0x3D43A0, symSize: 0x87 }
+  - { offsetInCU: 0x34, offset: 0xA36DA, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_neg_inv_mod_r_u64, symObjAddr: 0x0, symBinAddr: 0x3D43A0, symSize: 0x87 }
+  - { offsetInCU: 0x26, offset: 0xA37EA, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_little_endian_bytes_from_scalar, symObjAddr: 0x0, symBinAddr: 0x3D4430, symSize: 0x46 }
+  - { offsetInCU: 0x34, offset: 0xA37F8, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_little_endian_bytes_from_scalar, symObjAddr: 0x0, symBinAddr: 0x3D4430, symSize: 0x46 }
+  - { offsetInCU: 0x86, offset: 0xA395B, size: 0x8, addend: 0x0, symName: _Q_N0, symObjAddr: 0x15F0, symBinAddr: 0xB63070, symSize: 0x0 }
+  - { offsetInCU: 0xB8, offset: 0xA398D, size: 0x8, addend: 0x0, symName: _Q, symObjAddr: 0x1580, symBinAddr: 0xB63000, symSize: 0x0 }
+  - { offsetInCU: 0xDA, offset: 0xA39AF, size: 0x8, addend: 0x0, symName: _N, symObjAddr: 0x15B0, symBinAddr: 0xB63030, symSize: 0x0 }
+  - { offsetInCU: 0xF0, offset: 0xA39C5, size: 0x8, addend: 0x0, symName: _N_N0, symObjAddr: 0x15E0, symBinAddr: 0xB63060, symSize: 0x0 }
+  - { offsetInCU: 0x3B7, offset: 0xA3C8C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_elem_mul_mont, symObjAddr: 0x150, symBinAddr: 0x3D4480, symSize: 0x20 }
+  - { offsetInCU: 0x594, offset: 0xA3E69, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_scalar_mul_mont, symObjAddr: 0x250, symBinAddr: 0x3D44A0, symSize: 0x20 }
+  - { offsetInCU: 0x63F, offset: 0xA3F14, size: 0x8, addend: 0x0, symName: _nistz384_point_double, symObjAddr: 0x340, symBinAddr: 0x3D44C0, symSize: 0x3A0 }
+  - { offsetInCU: 0x11A7, offset: 0xA4A7C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_point_add, symObjAddr: 0x6E0, symBinAddr: 0x3D4860, symSize: 0x140 }
+  - { offsetInCU: 0x14A2, offset: 0xA4D77, size: 0x8, addend: 0x0, symName: _nistz384_point_add, symObjAddr: 0x820, symBinAddr: 0x3D49A0, symSize: 0x6B0 }
+  - { offsetInCU: 0x26DA, offset: 0xA5FAF, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_point_mul, symObjAddr: 0xED0, symBinAddr: 0x3D5050, symSize: 0x380 }
+  - { offsetInCU: 0x2D37, offset: 0xA660C, size: 0x8, addend: 0x0, symName: _p384_point_select_w5, symObjAddr: 0x1250, symBinAddr: 0x3D53D0, symSize: 0x170 }
+  - { offsetInCU: 0x2F2F, offset: 0xA6804, size: 0x8, addend: 0x0, symName: _add_precomputed_w5, symObjAddr: 0x13C0, symBinAddr: 0x3D5540, symSize: 0x1BF }
+  - { offsetInCU: 0x26, offset: 0xA6B4F, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_zero, symObjAddr: 0x0, symBinAddr: 0x3D5700, symSize: 0x50 }
+  - { offsetInCU: 0xFA, offset: 0xA6C23, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_zero, symObjAddr: 0x0, symBinAddr: 0x3D5700, symSize: 0x50 }
+  - { offsetInCU: 0x18D, offset: 0xA6CB6, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_equal, symObjAddr: 0x50, symBinAddr: 0x3D5750, symSize: 0x60 }
+  - { offsetInCU: 0x2F1, offset: 0xA6E1A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_equal_limb, symObjAddr: 0xB0, symBinAddr: 0x3D57B0, symSize: 0x90 }
+  - { offsetInCU: 0x4C6, offset: 0xA6FEF, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_even, symObjAddr: 0x140, symBinAddr: 0x3D5840, symSize: 0x20 }
+  - { offsetInCU: 0x5E3, offset: 0xA710C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_less_than, symObjAddr: 0x160, symBinAddr: 0x3D5860, symSize: 0xB0 }
+  - { offsetInCU: 0x696, offset: 0xA71BF, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_less_than_limb, symObjAddr: 0x210, symBinAddr: 0x3D5910, symSize: 0x70 }
+  - { offsetInCU: 0x861, offset: 0xA738A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_reduce_once, symObjAddr: 0x280, symBinAddr: 0x3D5980, symSize: 0x170 }
+  - { offsetInCU: 0xB67, offset: 0xA7690, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_add_mod, symObjAddr: 0x3F0, symBinAddr: 0x3D5AF0, symSize: 0x270 }
+  - { offsetInCU: 0xE6A, offset: 0xA7993, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_sub_mod, symObjAddr: 0x660, symBinAddr: 0x3D5D60, symSize: 0x1A0 }
+  - { offsetInCU: 0x105D, offset: 0xA7B86, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_shl_mod, symObjAddr: 0x800, symBinAddr: 0x3D5F00, symSize: 0x280 }
+  - { offsetInCU: 0x128C, offset: 0xA7DB5, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_window5_split_window, symObjAddr: 0xC20, symBinAddr: 0x3D6180, symSize: 0x20 }
+  - { offsetInCU: 0x12F3, offset: 0xA7E1C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_window5_unsplit_window, symObjAddr: 0xC40, symBinAddr: 0x3D61A0, symSize: 0x20 }
+  - { offsetInCU: 0x132A, offset: 0xA7E53, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMB_shr, symObjAddr: 0xC60, symBinAddr: 0x3D61C0, symSize: 0x10 }
+  - { offsetInCU: 0x13AC, offset: 0xA7ED5, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_limbs_mul_add_limb, symObjAddr: 0xC70, symBinAddr: 0x3D61D0, symSize: 0x4A }
+  - { offsetInCU: 0x26, offset: 0xA8061, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_CRYPTO_memcmp, symObjAddr: 0x0, symBinAddr: 0x3D6220, symSize: 0x129 }
+  - { offsetInCU: 0x34, offset: 0xA806F, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_CRYPTO_memcmp, symObjAddr: 0x0, symBinAddr: 0x3D6220, symSize: 0x129 }
+  - { offsetInCU: 0x34, offset: 0xA8171, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_OPENSSL_ia32cap_P, symObjAddr: 0x3F0, symBinAddr: 0x136B210, symSize: 0x0 }
+  - { offsetInCU: 0x26, offset: 0xA81C6, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_OPENSSL_cpuid_setup, symObjAddr: 0x0, symBinAddr: 0x3D6350, symSize: 0xF8 }
+  - { offsetInCU: 0xD5, offset: 0xA8275, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_OPENSSL_cpuid_setup, symObjAddr: 0x0, symBinAddr: 0x3D6350, symSize: 0xF8 }
+  - { offsetInCU: 0x26, offset: 0xA83CA, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_scalar_mult_adx, symObjAddr: 0x0, symBinAddr: 0x3D6450, symSize: 0x1210 }
+  - { offsetInCU: 0x92E, offset: 0xA8CD2, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_scalar_mult_adx, symObjAddr: 0x0, symBinAddr: 0x3D6450, symSize: 0x1210 }
+  - { offsetInCU: 0x5347, offset: 0xAD6EB, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_scalarmult_base_adx, symObjAddr: 0x1210, symBinAddr: 0x3D7660, symSize: 0x1E50 }
+  - { offsetInCU: 0x9B2F, offset: 0xB1ED3, size: 0x8, addend: 0x0, symName: _inline_x25519_ge_dbl_4, symObjAddr: 0x3060, symBinAddr: 0x3D94B0, symSize: 0x361 }
+  - { offsetInCU: 0x26, offset: 0xB32C0, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_CRYPTO_poly1305_init, symObjAddr: 0x0, symBinAddr: 0x3D9820, symSize: 0xD0 }
+  - { offsetInCU: 0x303, offset: 0xB359D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_CRYPTO_poly1305_init, symObjAddr: 0x0, symBinAddr: 0x3D9820, symSize: 0xD0 }
+  - { offsetInCU: 0x5A4, offset: 0xB383E, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_CRYPTO_poly1305_update, symObjAddr: 0xD0, symBinAddr: 0x3D98F0, symSize: 0x1C0 }
+  - { offsetInCU: 0x764, offset: 0xB39FE, size: 0x8, addend: 0x0, symName: _poly1305_blocks, symObjAddr: 0x5F0, symBinAddr: 0x3D9E10, symSize: 0x780 }
+  - { offsetInCU: 0x903, offset: 0xB3B9D, size: 0x8, addend: 0x0, symName: _poly1305_first_block, symObjAddr: 0x290, symBinAddr: 0x3D9AB0, symSize: 0x360 }
+  - { offsetInCU: 0xEFC, offset: 0xB4196, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_CRYPTO_poly1305_finish, symObjAddr: 0xD70, symBinAddr: 0x3DA590, symSize: 0xAA2 }
+  - { offsetInCU: 0x10, offset: 0xB491F, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_fiat_curve25519_adx_mul, symObjAddr: 0x0, symBinAddr: 0x3DB032, symSize: 0x2AF }
+  - { offsetInCU: 0x51, offset: 0xB4960, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_fiat_curve25519_adx_mul, symObjAddr: 0x0, symBinAddr: 0x3DB032, symSize: 0x2AF }
+  - { offsetInCU: 0x10, offset: 0xB4955, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_fiat_curve25519_adx_square, symObjAddr: 0x0, symBinAddr: 0x3DB2E1, symSize: 0x1F4 }
+  - { offsetInCU: 0x54, offset: 0xB4999, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_fiat_curve25519_adx_square, symObjAddr: 0x0, symBinAddr: 0x3DB2E1, symSize: 0x1F4 }
+  - { offsetInCU: 0x26, offset: 0xB49A1, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul, symObjAddr: 0x0, symBinAddr: 0x3DB4E0, symSize: 0x490 }
+  - { offsetInCU: 0x76, offset: 0xB49F1, size: 0x8, addend: 0x0, symName: _ecp_nistz256_precomputed, symObjAddr: 0x1000, symBinAddr: 0xB64000, symSize: 0x0 }
+  - { offsetInCU: 0xFA, offset: 0xB4A75, size: 0x8, addend: 0x0, symName: _ONE, symObjAddr: 0x26000, symBinAddr: 0xB89000, symSize: 0x0 }
+  - { offsetInCU: 0x35B, offset: 0xB4CD6, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul, symObjAddr: 0x0, symBinAddr: 0x3DB4E0, symSize: 0x490 }
+  - { offsetInCU: 0xC5A, offset: 0xB55D5, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul_base, symObjAddr: 0x490, symBinAddr: 0x3DB970, symSize: 0x300 }
+  - { offsetInCU: 0x1135, offset: 0xB5AB0, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul_base_vartime, symObjAddr: 0x790, symBinAddr: 0x3DBC70, symSize: 0x25D }
+  - { offsetInCU: 0x10, offset: 0xB5E75, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ChaCha20_ctr32, symObjAddr: 0x0, symBinAddr: 0x3DBF00, symSize: 0x3A0 }
+  - { offsetInCU: 0x48, offset: 0xB5EAD, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ChaCha20_ctr32, symObjAddr: 0x0, symBinAddr: 0x3DBF00, symSize: 0x3A0 }
+  - { offsetInCU: 0x4D, offset: 0xB5EB2, size: 0x8, addend: 0x0, symName: ChaCha20_ssse3, symObjAddr: 0x3A0, symBinAddr: 0x3DC2A0, symSize: 0x220 }
+  - { offsetInCU: 0x60, offset: 0xB5EC5, size: 0x8, addend: 0x0, symName: ChaCha20_4x, symObjAddr: 0x5C0, symBinAddr: 0x3DC4C0, symSize: 0xA20 }
+  - { offsetInCU: 0x76, offset: 0xB5EDB, size: 0x8, addend: 0x0, symName: ChaCha20_8x, symObjAddr: 0xFE0, symBinAddr: 0x3DCEE0, symSize: 0xB4C }
+  - { offsetInCU: 0x10, offset: 0xB5EED, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_encrypt, symObjAddr: 0x0, symBinAddr: 0x3DDA40, symSize: 0x40 }
+  - { offsetInCU: 0x48, offset: 0xB5F25, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_encrypt, symObjAddr: 0x0, symBinAddr: 0x3DDA40, symSize: 0x40 }
+  - { offsetInCU: 0x4D, offset: 0xB5F2A, size: 0x8, addend: 0x0, symName: _aesni_encrypt2, symObjAddr: 0x40, symBinAddr: 0x3DDA80, symSize: 0x60 }
+  - { offsetInCU: 0x63, offset: 0xB5F40, size: 0x8, addend: 0x0, symName: _aesni_encrypt3, symObjAddr: 0xA0, symBinAddr: 0x3DDAE0, symSize: 0x70 }
+  - { offsetInCU: 0x79, offset: 0xB5F56, size: 0x8, addend: 0x0, symName: _aesni_encrypt4, symObjAddr: 0x110, symBinAddr: 0x3DDB50, symSize: 0x90 }
+  - { offsetInCU: 0x8F, offset: 0xB5F6C, size: 0x8, addend: 0x0, symName: _aesni_encrypt6, symObjAddr: 0x1A0, symBinAddr: 0x3DDBE0, symSize: 0xE0 }
+  - { offsetInCU: 0xA5, offset: 0xB5F82, size: 0x8, addend: 0x0, symName: _aesni_encrypt8, symObjAddr: 0x280, symBinAddr: 0x3DDCC0, symSize: 0x110 }
+  - { offsetInCU: 0xD9, offset: 0xB5FB6, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_ctr32_encrypt_blocks, symObjAddr: 0x390, symBinAddr: 0x3DDDD0, symSize: 0x940 }
+  - { offsetInCU: 0xEA, offset: 0xB5FC7, size: 0x8, addend: 0x0, symName: __aesni_set_encrypt_key, symObjAddr: 0xCD0, symBinAddr: 0x3DE710, symSize: 0x44D }
+  - { offsetInCU: 0x10, offset: 0xB5FBD, size: 0x8, addend: 0x0, symName: _vpaes_encrypt_core, symObjAddr: 0x0, symBinAddr: 0x3DEB60, symSize: 0x160 }
+  - { offsetInCU: 0x3B, offset: 0xB5FE8, size: 0x8, addend: 0x0, symName: _vpaes_encrypt_core, symObjAddr: 0x0, symBinAddr: 0x3DEB60, symSize: 0x160 }
+  - { offsetInCU: 0x54, offset: 0xB6001, size: 0x8, addend: 0x0, symName: _vpaes_encrypt_core_2x, symObjAddr: 0x160, symBinAddr: 0x3DECC0, symSize: 0x290 }
+  - { offsetInCU: 0x68, offset: 0xB6015, size: 0x8, addend: 0x0, symName: _vpaes_schedule_core, symObjAddr: 0x3F0, symBinAddr: 0x3DEF50, symSize: 0xF0 }
+  - { offsetInCU: 0x7F, offset: 0xB602C, size: 0x8, addend: 0x0, symName: _vpaes_schedule_round, symObjAddr: 0x4E0, symBinAddr: 0x3DF040, symSize: 0x21 }
+  - { offsetInCU: 0x99, offset: 0xB6046, size: 0x8, addend: 0x0, symName: _vpaes_schedule_low_round, symObjAddr: 0x501, symBinAddr: 0x3DF061, symSize: 0x9F }
+  - { offsetInCU: 0xAF, offset: 0xB605C, size: 0x8, addend: 0x0, symName: _vpaes_schedule_transform, symObjAddr: 0x5A0, symBinAddr: 0x3DF100, symSize: 0x30 }
+  - { offsetInCU: 0xC2, offset: 0xB606F, size: 0x8, addend: 0x0, symName: _vpaes_schedule_mangle, symObjAddr: 0x5D0, symBinAddr: 0x3DF130, symSize: 0x50 }
+  - { offsetInCU: 0xE9, offset: 0xB6096, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_vpaes_set_encrypt_key, symObjAddr: 0x620, symBinAddr: 0x3DF180, symSize: 0x30 }
+  - { offsetInCU: 0xF7, offset: 0xB60A4, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_vpaes_encrypt, symObjAddr: 0x650, symBinAddr: 0x3DF1B0, symSize: 0x20 }
+  - { offsetInCU: 0x11A, offset: 0xB60C7, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_vpaes_ctr32_encrypt_blocks, symObjAddr: 0x670, symBinAddr: 0x3DF1D0, symSize: 0xD0 }
+  - { offsetInCU: 0x112, offset: 0xB60BF, size: 0x8, addend: 0x0, symName: _vpaes_preheat, symObjAddr: 0x740, symBinAddr: 0x3DF2A0, symSize: 0x31 }
+  - { offsetInCU: 0x10, offset: 0xB60CF, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_mul_mont, symObjAddr: 0x0, symBinAddr: 0x3DF2E0, symSize: 0x2A0 }
+  - { offsetInCU: 0x45, offset: 0xB6104, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_mul_mont, symObjAddr: 0x0, symBinAddr: 0x3DF2E0, symSize: 0x2A0 }
+  - { offsetInCU: 0x4C, offset: 0xB610B, size: 0x8, addend: 0x0, symName: bn_mul4x_mont, symObjAddr: 0x2A0, symBinAddr: 0x3DF580, symSize: 0x560 }
+  - { offsetInCU: 0x62, offset: 0xB6121, size: 0x8, addend: 0x0, symName: bn_sqr8x_mont, symObjAddr: 0x800, symBinAddr: 0x3DFAE0, symSize: 0x220 }
+  - { offsetInCU: 0x79, offset: 0xB6138, size: 0x8, addend: 0x0, symName: bn_mulx4x_mont, symObjAddr: 0xA20, symBinAddr: 0x3DFD00, symSize: 0x570 }
+  - { offsetInCU: 0x10, offset: 0xB6147, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_mul_mont_gather5, symObjAddr: 0x0, symBinAddr: 0x3E0280, symSize: 0x660 }
+  - { offsetInCU: 0x4D, offset: 0xB6184, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_mul_mont_gather5, symObjAddr: 0x0, symBinAddr: 0x3E0280, symSize: 0x660 }
+  - { offsetInCU: 0x54, offset: 0xB618B, size: 0x8, addend: 0x0, symName: bn_mul4x_mont_gather5, symObjAddr: 0x660, symBinAddr: 0x3E08E0, symSize: 0x100 }
+  - { offsetInCU: 0x63, offset: 0xB619A, size: 0x8, addend: 0x0, symName: mul4x_internal, symObjAddr: 0x760, symBinAddr: 0x3E09E0, symSize: 0x7E0 }
+  - { offsetInCU: 0x85, offset: 0xB61BC, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_power5, symObjAddr: 0xF40, symBinAddr: 0x3E11C0, symSize: 0x180 }
+  - { offsetInCU: 0xA3, offset: 0xB61DA, size: 0x8, addend: 0x0, symName: __bn_sqr8x_internal, symObjAddr: 0x10C0, symBinAddr: 0x3E1340, symSize: 0x579 }
+  - { offsetInCU: 0xAA, offset: 0xB61E1, size: 0x8, addend: 0x0, symName: __bn_sqr8x_reduction, symObjAddr: 0x1639, symBinAddr: 0x3E18B9, symSize: 0x347 }
+  - { offsetInCU: 0xC0, offset: 0xB61F7, size: 0x8, addend: 0x0, symName: __bn_post4x_internal, symObjAddr: 0x1980, symBinAddr: 0x3E1C00, symSize: 0xA0 }
+  - { offsetInCU: 0xD9, offset: 0xB6210, size: 0x8, addend: 0x0, symName: bn_mulx4x_mont_gather5, symObjAddr: 0x1A20, symBinAddr: 0x3E1CA0, symSize: 0xE0 }
+  - { offsetInCU: 0xE8, offset: 0xB621F, size: 0x8, addend: 0x0, symName: mulx4x_internal, symObjAddr: 0x1B00, symBinAddr: 0x3E1D80, symSize: 0x7E0 }
+  - { offsetInCU: 0xF9, offset: 0xB6230, size: 0x8, addend: 0x0, symName: bn_powerx5, symObjAddr: 0x22E0, symBinAddr: 0x3E2560, symSize: 0x160 }
+  - { offsetInCU: 0x128, offset: 0xB625F, size: 0x8, addend: 0x0, symName: __bn_sqrx8x_internal, symObjAddr: 0x2440, symBinAddr: 0x3E26C0, symSize: 0x637 }
+  - { offsetInCU: 0x12F, offset: 0xB6266, size: 0x8, addend: 0x0, symName: __bn_sqrx8x_reduction, symObjAddr: 0x2A77, symBinAddr: 0x3E2CF7, symSize: 0x329 }
+  - { offsetInCU: 0x145, offset: 0xB627C, size: 0x8, addend: 0x0, symName: __bn_postx4x_internal, symObjAddr: 0x2DA0, symBinAddr: 0x3E3020, symSize: 0x90 }
+  - { offsetInCU: 0x163, offset: 0xB629A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_scatter5, symObjAddr: 0x2E30, symBinAddr: 0x3E30B0, symSize: 0x30 }
+  - { offsetInCU: 0x178, offset: 0xB62AF, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_gather5, symObjAddr: 0x2E60, symBinAddr: 0x3E30E0, symSize: 0x27F }
+  - { offsetInCU: 0x10, offset: 0xB62B1, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ecp_nistz256_neg, symObjAddr: 0x0, symBinAddr: 0x3E3360, symSize: 0x80 }
+  - { offsetInCU: 0x4A, offset: 0xB62EB, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ecp_nistz256_neg, symObjAddr: 0x0, symBinAddr: 0x3E3360, symSize: 0x80 }
+  - { offsetInCU: 0x64, offset: 0xB6305, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_scalar_mul_mont, symObjAddr: 0x80, symBinAddr: 0x3E33E0, symSize: 0x360 }
+  - { offsetInCU: 0x7E, offset: 0xB631F, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_scalar_sqr_rep_mont, symObjAddr: 0x3E0, symBinAddr: 0x3E3740, symSize: 0x300 }
+  - { offsetInCU: 0x85, offset: 0xB6326, size: 0x8, addend: 0x0, symName: ecp_nistz256_ord_mul_montx, symObjAddr: 0x6E0, symBinAddr: 0x3E3A40, symSize: 0x3C0 }
+  - { offsetInCU: 0x9B, offset: 0xB633C, size: 0x8, addend: 0x0, symName: ecp_nistz256_ord_sqr_montx, symObjAddr: 0xAA0, symBinAddr: 0x3E3E00, symSize: 0x320 }
+  - { offsetInCU: 0xB5, offset: 0xB6356, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_mul_mont, symObjAddr: 0xDC0, symBinAddr: 0x3E4120, symSize: 0xA0 }
+  - { offsetInCU: 0xC4, offset: 0xB6365, size: 0x8, addend: 0x0, symName: __ecp_nistz256_mul_montq, symObjAddr: 0xE60, symBinAddr: 0x3E41C0, symSize: 0x240 }
+  - { offsetInCU: 0xE1, offset: 0xB6382, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_sqr_mont, symObjAddr: 0x10A0, symBinAddr: 0x3E4400, symSize: 0x80 }
+  - { offsetInCU: 0xF0, offset: 0xB6391, size: 0x8, addend: 0x0, symName: __ecp_nistz256_sqr_montq, symObjAddr: 0x1120, symBinAddr: 0x3E4480, symSize: 0x1A0 }
+  - { offsetInCU: 0x106, offset: 0xB63A7, size: 0x8, addend: 0x0, symName: __ecp_nistz256_mul_montx, symObjAddr: 0x12C0, symBinAddr: 0x3E4620, symSize: 0x260 }
+  - { offsetInCU: 0x11C, offset: 0xB63BD, size: 0x8, addend: 0x0, symName: __ecp_nistz256_sqr_montx, symObjAddr: 0x1520, symBinAddr: 0x3E4880, symSize: 0x1C0 }
+  - { offsetInCU: 0x142, offset: 0xB63E3, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ecp_nistz256_select_w5, symObjAddr: 0x16E0, symBinAddr: 0x3E4A40, symSize: 0xE0 }
+  - { offsetInCU: 0x158, offset: 0xB63F9, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ecp_nistz256_select_w7, symObjAddr: 0x17C0, symBinAddr: 0x3E4B20, symSize: 0xC0 }
+  - { offsetInCU: 0x162, offset: 0xB6403, size: 0x8, addend: 0x0, symName: ecp_nistz256_avx2_select_w5, symObjAddr: 0x1880, symBinAddr: 0x3E4BE0, symSize: 0xC0 }
+  - { offsetInCU: 0x178, offset: 0xB6419, size: 0x8, addend: 0x0, symName: ecp_nistz256_avx2_select_w7, symObjAddr: 0x1940, symBinAddr: 0x3E4CA0, symSize: 0xE0 }
+  - { offsetInCU: 0x188, offset: 0xB6429, size: 0x8, addend: 0x0, symName: __ecp_nistz256_add_toq, symObjAddr: 0x1A20, symBinAddr: 0x3E4D80, symSize: 0x60 }
+  - { offsetInCU: 0x1A0, offset: 0xB6441, size: 0x8, addend: 0x0, symName: __ecp_nistz256_sub_fromq, symObjAddr: 0x1A80, symBinAddr: 0x3E4DE0, symSize: 0x60 }
+  - { offsetInCU: 0x1B1, offset: 0xB6452, size: 0x8, addend: 0x0, symName: __ecp_nistz256_subq, symObjAddr: 0x1AE0, symBinAddr: 0x3E4E40, symSize: 0x40 }
+  - { offsetInCU: 0x1CC, offset: 0xB646D, size: 0x8, addend: 0x0, symName: __ecp_nistz256_mul_by_2q, symObjAddr: 0x1B20, symBinAddr: 0x3E4E80, symSize: 0x60 }
+  - { offsetInCU: 0x1ED, offset: 0xB648E, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_double, symObjAddr: 0x1B80, symBinAddr: 0x3E4EE0, symSize: 0x320 }
+  - { offsetInCU: 0x200, offset: 0xB64A1, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_add, symObjAddr: 0x1EA0, symBinAddr: 0x3E5200, symSize: 0x780 }
+  - { offsetInCU: 0x21D, offset: 0xB64BE, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_add_affine, symObjAddr: 0x2620, symBinAddr: 0x3E5980, symSize: 0x580 }
+  - { offsetInCU: 0x222, offset: 0xB64C3, size: 0x8, addend: 0x0, symName: __ecp_nistz256_add_tox, symObjAddr: 0x2BA0, symBinAddr: 0x3E5F00, symSize: 0x60 }
+  - { offsetInCU: 0x23A, offset: 0xB64DB, size: 0x8, addend: 0x0, symName: __ecp_nistz256_sub_fromx, symObjAddr: 0x2C00, symBinAddr: 0x3E5F60, symSize: 0x60 }
+  - { offsetInCU: 0x24B, offset: 0xB64EC, size: 0x8, addend: 0x0, symName: __ecp_nistz256_subx, symObjAddr: 0x2C60, symBinAddr: 0x3E5FC0, symSize: 0x60 }
+  - { offsetInCU: 0x266, offset: 0xB6507, size: 0x8, addend: 0x0, symName: __ecp_nistz256_mul_by_2x, symObjAddr: 0x2CC0, symBinAddr: 0x3E6020, symSize: 0x60 }
+  - { offsetInCU: 0x27F, offset: 0xB6520, size: 0x8, addend: 0x0, symName: ecp_nistz256_point_doublex, symObjAddr: 0x2D20, symBinAddr: 0x3E6080, symSize: 0x320 }
+  - { offsetInCU: 0x292, offset: 0xB6533, size: 0x8, addend: 0x0, symName: ecp_nistz256_point_addx, symObjAddr: 0x3040, symBinAddr: 0x3E63A0, symSize: 0x760 }
+  - { offsetInCU: 0x2AF, offset: 0xB6550, size: 0x8, addend: 0x0, symName: ecp_nistz256_point_add_affinex, symObjAddr: 0x37A0, symBinAddr: 0x3E6B00, symSize: 0x555 }
+  - { offsetInCU: 0x10, offset: 0xB654F, size: 0x8, addend: 0x0, symName: _aesni_ctr32_ghash_6x, symObjAddr: 0x0, symBinAddr: 0x3E7060, symSize: 0x5A0 }
+  - { offsetInCU: 0x3D, offset: 0xB657C, size: 0x8, addend: 0x0, symName: _aesni_ctr32_ghash_6x, symObjAddr: 0x0, symBinAddr: 0x3E7060, symSize: 0x5A0 }
+  - { offsetInCU: 0x61, offset: 0xB65A0, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aesni_gcm_decrypt, symObjAddr: 0x5A0, symBinAddr: 0x3E7600, symSize: 0x140 }
+  - { offsetInCU: 0x63, offset: 0xB65A2, size: 0x8, addend: 0x0, symName: _aesni_ctr32_6x, symObjAddr: 0x6E0, symBinAddr: 0x3E7740, symSize: 0x180 }
+  - { offsetInCU: 0x8D, offset: 0xB65CC, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aesni_gcm_encrypt, symObjAddr: 0x860, symBinAddr: 0x3E78C0, symSize: 0x423 }
+  - { offsetInCU: 0x10, offset: 0xB65C7, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_init_clmul, symObjAddr: 0x0, symBinAddr: 0x3E7D00, symSize: 0x260 }
+  - { offsetInCU: 0x48, offset: 0xB65FF, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_init_clmul, symObjAddr: 0x0, symBinAddr: 0x3E7D00, symSize: 0x260 }
+  - { offsetInCU: 0x5F, offset: 0xB6616, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_gmult_clmul, symObjAddr: 0x260, symBinAddr: 0x3E7F60, symSize: 0xC0 }
+  - { offsetInCU: 0x75, offset: 0xB662C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_ghash_clmul, symObjAddr: 0x320, symBinAddr: 0x3E8020, symSize: 0x660 }
+  - { offsetInCU: 0x88, offset: 0xB663F, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_init_avx, symObjAddr: 0x980, symBinAddr: 0x3E8680, symSize: 0x1A0 }
+  - { offsetInCU: 0x9F, offset: 0xB6656, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_ghash_avx, symObjAddr: 0xB20, symBinAddr: 0x3E8820, symSize: 0x697 }
+  - { offsetInCU: 0x10, offset: 0xB6655, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha512_block_data_order, symObjAddr: 0x0, symBinAddr: 0x3E8EC0, symSize: 0x1240 }
+  - { offsetInCU: 0x51, offset: 0xB6696, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha512_block_data_order, symObjAddr: 0x0, symBinAddr: 0x3E8EC0, symSize: 0x1240 }
+  - { offsetInCU: 0x5A, offset: 0xB669F, size: 0x8, addend: 0x0, symName: sha512_block_data_order_avx, symObjAddr: 0x1240, symBinAddr: 0x3EA100, symSize: 0x1176 }
+  - { offsetInCU: 0x10, offset: 0xB66A1, size: 0x8, addend: 0x0, symName: poly_hash_ad_internal, symObjAddr: 0x0, symBinAddr: 0x3EB280, symSize: 0x200 }
+  - { offsetInCU: 0x44, offset: 0xB66D5, size: 0x8, addend: 0x0, symName: poly_hash_ad_internal, symObjAddr: 0x0, symBinAddr: 0x3EB280, symSize: 0x200 }
+  - { offsetInCU: 0x66, offset: 0xB66F7, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_chacha20_poly1305_open, symObjAddr: 0x200, symBinAddr: 0x3EB480, symSize: 0x21C0 }
+  - { offsetInCU: 0x7C, offset: 0xB670D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_chacha20_poly1305_seal, symObjAddr: 0x23C0, symBinAddr: 0x3ED640, symSize: 0x1D2D }
+  - { offsetInCU: 0x83, offset: 0xB6714, size: 0x8, addend: 0x0, symName: process_extra_in_trailer, symObjAddr: 0x40ED, symBinAddr: 0x3EF36D, symSize: 0x553 }
+  - { offsetInCU: 0x9C, offset: 0xB672D, size: 0x8, addend: 0x0, symName: chacha20_poly1305_open_avx2, symObjAddr: 0x4640, symBinAddr: 0x3EF8C0, symSize: 0x25C0 }
+  - { offsetInCU: 0xB2, offset: 0xB6743, size: 0x8, addend: 0x0, symName: chacha20_poly1305_seal_avx2, symObjAddr: 0x6C00, symBinAddr: 0x3F1E80, symSize: 0x2F01 }
+  - { offsetInCU: 0x10, offset: 0xB6745, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha256_block_data_order, symObjAddr: 0x0, symBinAddr: 0x3F4DC0, symSize: 0x1200 }
+  - { offsetInCU: 0x51, offset: 0xB6786, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha256_block_data_order, symObjAddr: 0x0, symBinAddr: 0x3F4DC0, symSize: 0x1200 }
+  - { offsetInCU: 0x5D, offset: 0xB6792, size: 0x8, addend: 0x0, symName: sha256_block_data_order_shaext, symObjAddr: 0x1200, symBinAddr: 0x3F5FC0, symSize: 0x340 }
+  - { offsetInCU: 0x72, offset: 0xB67A7, size: 0x8, addend: 0x0, symName: sha256_block_data_order_ssse3, symObjAddr: 0x1540, symBinAddr: 0x3F6300, symSize: 0xEC0 }
+  - { offsetInCU: 0x86, offset: 0xB67BB, size: 0x8, addend: 0x0, symName: sha256_block_data_order_avx, symObjAddr: 0x2400, symBinAddr: 0x3F71C0, symSize: 0xEF7 }
 ...
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUAdapterImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUAdapterImpl.cpp
index 48c1b85b3..208aef5b0 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUAdapterImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUAdapterImpl.cpp
@@ -21,7 +21,7 @@ void GPUAdapterImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isola
     auto context = isolate->GetCurrentContext();
     auto func = ctor->GetFunction(context).ToLocalChecked();
 
-    canvasModule->Set(context, ConvertToV8String(isolate, "GPUAdapter"), func);
+    canvasModule->Set(context, ConvertToV8String(isolate, "GPUAdapter"), func).FromJust();
 }
 
 GPUAdapterImpl *GPUAdapterImpl::GetPointer(const v8::Local<v8::Object> &object) {
@@ -245,7 +245,7 @@ void GPUAdapterImpl::RequestDevice(const v8::FunctionCallbackInfo<v8::Value> &ar
                                         label.empty() ? nullptr : label.c_str(),
                                         required_features_data, required_features_data_length,
                                         limits,
-                                        [](char *error, CanvasGPUDevice *device, void *data) {
+                                        [](char *error, const CanvasGPUDevice *device, void *data) {
                                             if (data != nullptr) {
                                                 auto func = static_cast<AsyncCallback *>(data);
                                                 if (func->isolate != nullptr) {
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUAdapterInfoImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUAdapterInfoImpl.cpp
index 3f8cfd7ce..a7c90eb5f 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUAdapterInfoImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUAdapterInfoImpl.cpp
@@ -5,9 +5,9 @@
 #include "GPUAdapterInfoImpl.h"
 #include "Caches.h"
 
-GPUAdapterInfoImpl::GPUAdapterInfoImpl(CanvasGPUAdapterInfo *info) : info_(info) {}
+GPUAdapterInfoImpl::GPUAdapterInfoImpl(const CanvasGPUAdapterInfo *info) : info_(info) {}
 
-CanvasGPUAdapterInfo *GPUAdapterInfoImpl::GetInfo() {
+const CanvasGPUAdapterInfo *GPUAdapterInfoImpl::GetInfo() {
     return this->info_;
 }
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUAdapterInfoImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUAdapterInfoImpl.h
index 50f884136..4b4beb9c6 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUAdapterInfoImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUAdapterInfoImpl.h
@@ -11,16 +11,13 @@
 
 class GPUAdapterInfoImpl : ObjectWrapperImpl {
 public:
-    GPUAdapterInfoImpl(CanvasGPUAdapterInfo *info);
+    GPUAdapterInfoImpl(const CanvasGPUAdapterInfo *info);
 
     ~GPUAdapterInfoImpl() {
-        if (this->info_ != nullptr) {
-            canvas_native_webgpu_adapter_info_destroy(this->info_);
-            this->info_ = nullptr;
-        }
+        canvas_native_webgpu_adapter_info_release(this->GetInfo());
     }
 
-    CanvasGPUAdapterInfo *GetInfo();
+    const CanvasGPUAdapterInfo *GetInfo();
 
     static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
 
@@ -54,7 +51,7 @@ class GPUAdapterInfoImpl : ObjectWrapperImpl {
 
 
 private:
-    CanvasGPUAdapterInfo *info_;
+    const CanvasGPUAdapterInfo *info_;
 };
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUBindGroupLayoutImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUBindGroupLayoutImpl.cpp
index e7437511d..cad58715d 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUBindGroupLayoutImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUBindGroupLayoutImpl.cpp
@@ -5,10 +5,10 @@
 #include "GPUBindGroupLayoutImpl.h"
 #include "Caches.h"
 
-GPUBindGroupLayoutImpl::GPUBindGroupLayoutImpl(CanvasGPUBindGroupLayout *groupLayout)
+GPUBindGroupLayoutImpl::GPUBindGroupLayoutImpl(const CanvasGPUBindGroupLayout *groupLayout)
         : groupLayout_(groupLayout) {}
 
-CanvasGPUBindGroupLayout *GPUBindGroupLayoutImpl::GetBindGroupLayout() {
+const CanvasGPUBindGroupLayout *GPUBindGroupLayoutImpl::GetBindGroupLayout() {
     return this->groupLayout_;
 }
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUBindGroupLayoutImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUBindGroupLayoutImpl.h
index 07da7bbbb..442fa95ec 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUBindGroupLayoutImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUBindGroupLayoutImpl.h
@@ -9,14 +9,15 @@
 #include "Helpers.h"
 #include "ObjectWrapperImpl.h"
 
-class GPUBindGroupLayoutImpl : ObjectWrapperImpl{
+class GPUBindGroupLayoutImpl : ObjectWrapperImpl {
 public:
-    GPUBindGroupLayoutImpl(CanvasGPUBindGroupLayout *groupLayout);
+    GPUBindGroupLayoutImpl(const CanvasGPUBindGroupLayout *groupLayout);
 
     ~GPUBindGroupLayoutImpl() {
+        canvas_native_webgpu_bind_group_layout_release(this->GetBindGroupLayout());
     }
 
-    CanvasGPUBindGroupLayout *GetBindGroupLayout();
+    const CanvasGPUBindGroupLayout *GetBindGroupLayout();
 
     static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
 
@@ -37,7 +38,7 @@ class GPUBindGroupLayoutImpl : ObjectWrapperImpl{
     }
 
 private:
-    CanvasGPUBindGroupLayout *groupLayout_;
+    const CanvasGPUBindGroupLayout *groupLayout_;
 };
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUBufferImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUBufferImpl.cpp
index cfd182498..fee4c0c7a 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUBufferImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUBufferImpl.cpp
@@ -5,9 +5,9 @@
 #include "GPUBufferImpl.h"
 #include "Caches.h"
 
-GPUBufferImpl::GPUBufferImpl(CanvasGPUBuffer *buffer) : buffer_(buffer) {}
+GPUBufferImpl::GPUBufferImpl(const CanvasGPUBuffer *buffer) : buffer_(buffer) {}
 
-CanvasGPUBuffer *GPUBufferImpl::GetGPUBuffer() {
+const CanvasGPUBuffer *GPUBufferImpl::GetGPUBuffer() {
     return this->buffer_;
 }
 
@@ -76,7 +76,6 @@ v8::Local<v8::FunctionTemplate> GPUBufferImpl::GetCtor(v8::Isolate *isolate) {
             v8::FunctionTemplate::New(isolate, &GetMappedRange));
 
 
-
     cache->GPUBufferTmpl =
             std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
     return ctorTmpl;
@@ -201,7 +200,6 @@ void GPUBufferImpl::GetMappedRange(const v8::FunctionCallbackInfo<v8::Value> &ar
     if (ptr == nullptr) {
         return;
     }
-    auto isolate = args.GetIsolate();
     int64_t offset = -1;
     int64_t size = -1;
 
@@ -218,10 +216,6 @@ void GPUBufferImpl::GetMappedRange(const v8::FunctionCallbackInfo<v8::Value> &ar
 
     auto buf = args[2].As<v8::ArrayBuffer>();
     auto store = buf->GetBackingStore();
-    auto error = canvas_native_webgpu_buffer_get_mapped_range(ptr->GetGPUBuffer(), offset, size,
+    canvas_native_webgpu_buffer_get_mapped_range(ptr->GetGPUBuffer(), offset, size,
                                                  (uint8_t *) store->Data(), store->ByteLength());
-
-    if (error != nullptr){
-        // todo error
-    }
 }
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUBufferImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUBufferImpl.h
index 554b8a525..73a6cc462 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUBufferImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUBufferImpl.h
@@ -10,12 +10,12 @@
 
 class GPUBufferImpl : ObjectWrapperImpl {
 public:
-    GPUBufferImpl(CanvasGPUBuffer *buffer);
+    GPUBufferImpl(const CanvasGPUBuffer *buffer);
 
     ~GPUBufferImpl() {
     }
 
-    CanvasGPUBuffer *GetGPUBuffer();
+    const CanvasGPUBuffer *GetGPUBuffer();
 
     static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
 
@@ -51,7 +51,7 @@ class GPUBufferImpl : ObjectWrapperImpl {
 
 
 private:
-    CanvasGPUBuffer *buffer_;
+    const CanvasGPUBuffer *buffer_;
 };
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCanvasContextImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCanvasContextImpl.cpp
index 137c35653..2eee5f14a 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCanvasContextImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCanvasContextImpl.cpp
@@ -4,10 +4,11 @@
 
 #include "GPUCanvasContextImpl.h"
 #include "Caches.h"
+#include "GPUAdapterImpl.h"
 
-GPUCanvasContextImpl::GPUCanvasContextImpl(CanvasGPUCanvasContext *context) : context_(context) {}
+GPUCanvasContextImpl::GPUCanvasContextImpl(const CanvasGPUCanvasContext *context) : context_(context) {}
 
-CanvasGPUCanvasContext *GPUCanvasContextImpl::GetContext() {
+const CanvasGPUCanvasContext *GPUCanvasContextImpl::GetContext() {
     return this->context_;
 }
 
@@ -24,7 +25,6 @@ void GPUCanvasContextImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolate
     canvasModule->Set(context, ConvertToV8String(isolate, "GPUCanvasContext"), func);
 }
 
-
 GPUCanvasContextImpl *GPUCanvasContextImpl::GetPointer(const v8::Local<v8::Object> &object) {
     auto ptr = object->GetAlignedPointerFromInternalField(0);
     if (ptr == nullptr) {
@@ -60,13 +60,20 @@ v8::Local<v8::FunctionTemplate> GPUCanvasContextImpl::GetCtor(v8::Isolate *isola
             ConvertToV8String(isolate, "getCurrentTexture"),
             v8::FunctionTemplate::New(isolate, &GetCurrentTexture));
 
+    tmpl->Set(
+            ConvertToV8String(isolate, "presentSurface"),
+            v8::FunctionTemplate::New(isolate, &PresentSurface));
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "capabilities"),
+            v8::FunctionTemplate::New(isolate, &GetCapabilities));
+
 
     cache->GPUCanvasContextTmpl =
             std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
     return ctorTmpl;
 }
 
-
 void GPUCanvasContextImpl::Configure(const v8::FunctionCallbackInfo<v8::Value> &args) {
     GPUCanvasContextImpl *ptr = GetPointer(args.This());
     auto isolate = args.GetIsolate();
@@ -75,104 +82,107 @@ void GPUCanvasContextImpl::Configure(const v8::FunctionCallbackInfo<v8::Value> &
     if (ptr == nullptr) {
         return;
     }
-    
+
     if (optionsValue->IsNullOrUndefined() || !optionsValue->IsObject()) {
         return;
     }
-    
+
     auto options = optionsValue.As<v8::Object>();
-    
+
     v8::Local<v8::Value> deviceValue;
-    
+
     options->Get(context, ConvertToV8String(isolate, "device")).ToLocal(
-                                                                        &deviceValue);
-    
-    
+            &deviceValue);
+
+
     if (deviceValue->IsNullOrUndefined() || !deviceValue->IsObject()) {
         return;
     }
-    
+
     auto device = GPUDeviceImpl::GetPointer(deviceValue.As<v8::Object>());
-    
+
     if (device == nullptr) { return; }
-    
+
     CanvasGPUSurfaceConfiguration config{};
     config.alphaMode = CanvasGPUSurfaceAlphaMode::CanvasGPUSurfaceAlphaModeOpaque;
     config.presentMode = CanvasGPUPresentMode::CanvasGPUPresentModeFifo;
     config.view_formats = nullptr;
     config.view_formats_size = 0;
     config.usage = 0x10;
-    
-    
+
+
     /* ignore for now
-     
+
      v8::Local<v8::Value> formatValue;
-     
-     
+
+
      options->Get(context, ConvertToV8String(isolate, "format")).ToLocal(
      &deviceValue);
-     
+
      */
-    
+
     v8::Local<v8::Value> usageValue;
-    
+
     options->Get(context, ConvertToV8String(isolate, "usage")).ToLocal(
-                                                                       &usageValue);
-    
+            &usageValue);
+
     if (!usageValue.IsEmpty() && usageValue->IsInt32()) {
         config.usage = usageValue->Int32Value(context).ToChecked();
     }
-    
-    
+
+
     v8::Local<v8::Value> presentModeValue;
-    
+
     options->Get(context, ConvertToV8String(isolate, "presentMode")).ToLocal(
-                                                                             &presentModeValue);
-    
+            &presentModeValue);
+
     if (!presentModeValue.IsEmpty()) {
-        if(presentModeValue->IsString()){
+        if (presentModeValue->IsString()) {
             auto presentMode = ConvertFromV8String(isolate, presentModeValue);
-            if(strcmp(presentMode.c_str(), "autoVsync") == 0){
+            if (strcmp(presentMode.c_str(), "autoVsync") == 0) {
                 config.presentMode = CanvasGPUPresentMode::CanvasGPUPresentModeAutoVsync;
-            }else if(strcmp(presentMode.c_str(), "autoNoVsync") == 0){
+            } else if (strcmp(presentMode.c_str(), "autoNoVsync") == 0) {
                 config.presentMode = CanvasGPUPresentMode::CanvasGPUPresentModeAutoNoVsync;
-            }else if(strcmp(presentMode.c_str(), "fifo") == 0){
+            } else if (strcmp(presentMode.c_str(), "fifo") == 0) {
                 config.presentMode = CanvasGPUPresentMode::CanvasGPUPresentModeFifo;
-            }else if(strcmp(presentMode.c_str(), "fifoRelaxed") == 0){
+            } else if (strcmp(presentMode.c_str(), "fifoRelaxed") == 0) {
                 config.presentMode = CanvasGPUPresentMode::CanvasGPUPresentModeFifoRelaxed;
-            }else if(strcmp(presentMode.c_str(), "immediate") == 0){
+            } else if (strcmp(presentMode.c_str(), "immediate") == 0) {
                 config.presentMode = CanvasGPUPresentMode::CanvasGPUPresentModeImmediate;
-            }else if(strcmp(presentMode.c_str(), "mailbox") == 0){
+            } else if (strcmp(presentMode.c_str(), "mailbox") == 0) {
                 config.presentMode = CanvasGPUPresentMode::CanvasGPUPresentModeMailbox;
             }
-            
-        }else if (presentModeValue->IsInt32()){
+
+        } else if (presentModeValue->IsInt32()) {
             config.presentMode = (CanvasGPUPresentMode) presentModeValue->Int32Value(
-                                                                                     context).ToChecked();
+                    context).ToChecked();
         }
     }
-    
-    
-    
+
+
     v8::Local<v8::Value> alphaModeValue;
     options->Get(context, ConvertToV8String(isolate, "alphaMode")).ToLocal(
-                                                                           &alphaModeValue);
-    
+            &alphaModeValue);
+
     if (!alphaModeValue.IsEmpty()) {
-        if(alphaModeValue->IsString()){
+        if (alphaModeValue->IsString()) {
             auto alphaMode = ConvertFromV8String(isolate, alphaModeValue);
-            if(strcmp(alphaMode.c_str(), "premultiplied") == 0){
+            if (strcmp(alphaMode.c_str(), "premultiplied") == 0) {
                 config.alphaMode = CanvasGPUSurfaceAlphaMode::CanvasGPUSurfaceAlphaModePreMultiplied;
-            }else if(strcmp(alphaMode.c_str(), "opaque") == 0){
+            } else if (strcmp(alphaMode.c_str(), "opaque") == 0) {
                 config.alphaMode = CanvasGPUSurfaceAlphaMode::CanvasGPUSurfaceAlphaModeOpaque;
-            }else if(strcmp(alphaMode.c_str(), "postmultiplied") == 0){
+            } else if (strcmp(alphaMode.c_str(), "postmultiplied") == 0) {
                 config.alphaMode = CanvasGPUSurfaceAlphaMode::CanvasGPUSurfaceAlphaModePostMultiplied;
+            } else if (strcmp(alphaMode.c_str(), "inherit") == 0) {
+                config.alphaMode = CanvasGPUSurfaceAlphaMode::CanvasGPUSurfaceAlphaModeInherit;
+            } else if (strcmp(alphaMode.c_str(), "auto") == 0) {
+                config.alphaMode = CanvasGPUSurfaceAlphaMode::CanvasGPUSurfaceAlphaModeAuto;
             }
-        }else if(alphaModeValue->IsInt32()){
+        } else if (alphaModeValue->IsInt32()) {
             config.alphaMode = (CanvasGPUSurfaceAlphaMode) alphaModeValue->Int32Value(
                     context).ToChecked();
         }
-        
+
     }
 
     canvas_native_webgpu_context_configure(ptr->GetContext(), device->GetGPUDevice(), &config);
@@ -196,7 +206,7 @@ void GPUCanvasContextImpl::GetCurrentTexture(const v8::FunctionCallbackInfo<v8::
         args.GetReturnValue().SetUndefined();
         return;
     }
-    
+
     auto ctx = ptr->GetContext();
 
     auto texture = canvas_native_webgpu_context_get_current_texture(ctx);
@@ -210,3 +220,35 @@ void GPUCanvasContextImpl::GetCurrentTexture(const v8::FunctionCallbackInfo<v8::
 
     args.GetReturnValue().SetUndefined();
 }
+
+void GPUCanvasContextImpl::PresentSurface(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    GPUCanvasContextImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto ctx = ptr->GetContext();
+
+    canvas_native_webgpu_context_present_surface(ctx);
+}
+
+void GPUCanvasContextImpl::GetCapabilities(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    GPUCanvasContextImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto adapterVal = args[0];
+
+    if (!adapterVal.IsEmpty() && adapterVal->IsObject()) {
+        auto adapter = GPUAdapterImpl::GetPointer(adapterVal.As<v8::Object>());
+        auto ctx = ptr->GetContext();
+
+        if (adapter != nullptr) {
+            canvas_native_webgpu_context_get_capabilities(ctx, adapter->GetGPUAdapter());
+        }
+
+
+    }
+    args.GetReturnValue().SetUndefined();
+}
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCanvasContextImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCanvasContextImpl.h
index 4824ef770..17a9896d4 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCanvasContextImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCanvasContextImpl.h
@@ -12,11 +12,11 @@
 
 class GPUCanvasContextImpl : ObjectWrapperImpl {
 public:
-    GPUCanvasContextImpl(CanvasGPUCanvasContext *context);
+    GPUCanvasContextImpl(const CanvasGPUCanvasContext *context);
 
     ~GPUCanvasContextImpl() {}
 
-    CanvasGPUCanvasContext *GetContext();
+    const CanvasGPUCanvasContext *GetContext();
 
     static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
 
@@ -41,8 +41,12 @@ class GPUCanvasContextImpl : ObjectWrapperImpl {
 
     static void GetCurrentTexture(const v8::FunctionCallbackInfo<v8::Value> &args);
 
+    static void PresentSurface(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetCapabilities(const v8::FunctionCallbackInfo<v8::Value> &args);
+
 private:
-    CanvasGPUCanvasContext *context_;
+    const CanvasGPUCanvasContext *context_;
 };
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCommandBufferImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCommandBufferImpl.cpp
index e0b0e0550..7cff7a60a 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCommandBufferImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCommandBufferImpl.cpp
@@ -5,10 +5,10 @@
 #include "GPUCommandBufferImpl.h"
 #include "Caches.h"
 
-GPUCommandBufferImpl::GPUCommandBufferImpl(CanvasGPUCommandBuffer *commandBuffer) : commandBuffer_(
+GPUCommandBufferImpl::GPUCommandBufferImpl(const CanvasGPUCommandBuffer *commandBuffer) : commandBuffer_(
         commandBuffer) {}
 
-CanvasGPUCommandBuffer *GPUCommandBufferImpl::GetGPUCommandBuffer() {
+const CanvasGPUCommandBuffer *GPUCommandBufferImpl::GetGPUCommandBuffer() {
     return this->commandBuffer_;
 }
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCommandBufferImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCommandBufferImpl.h
index 7c957182b..8bdfeb0bf 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCommandBufferImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCommandBufferImpl.h
@@ -11,12 +11,12 @@
 
 class GPUCommandBufferImpl : ObjectWrapperImpl {
 public:
-    GPUCommandBufferImpl(CanvasGPUCommandBuffer *commandBuffer);
+    GPUCommandBufferImpl(const CanvasGPUCommandBuffer *commandBuffer);
 
     ~GPUCommandBufferImpl() {
     }
 
-    CanvasGPUCommandBuffer *GetGPUCommandBuffer();
+    const CanvasGPUCommandBuffer *GetGPUCommandBuffer();
 
     static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
 
@@ -37,7 +37,7 @@ class GPUCommandBufferImpl : ObjectWrapperImpl {
     }
 
 private:
-    CanvasGPUCommandBuffer *commandBuffer_;
+    const CanvasGPUCommandBuffer *commandBuffer_;
 };
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCommandEncoderImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCommandEncoderImpl.cpp
index 0b7ec8857..b08d35426 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCommandEncoderImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCommandEncoderImpl.cpp
@@ -4,17 +4,17 @@
 
 #include "GPUCommandEncoderImpl.h"
 #include "Caches.h"
-#include "GPUComputePassImpl.h"
+#include "GPUComputePassEncoderImpl.h"
 #include "GPUQuerySetImpl.h"
 #include "GPUBufferImpl.h"
 #include "GPUTextureViewImpl.h"
 #include "GPURenderPassEncoderImpl.h"
 #include "GPUCommandBufferImpl.h"
 
-GPUCommandEncoderImpl::GPUCommandEncoderImpl(CanvasGPUCommandEncoder *encoder) : encoder_(
+GPUCommandEncoderImpl::GPUCommandEncoderImpl(const CanvasGPUCommandEncoder *encoder) : encoder_(
         encoder) {}
 
-CanvasGPUCommandEncoder *GPUCommandEncoderImpl::GetEncoder() {
+const CanvasGPUCommandEncoder *GPUCommandEncoderImpl::GetEncoder() {
     return this->encoder_;
 }
 
@@ -87,7 +87,7 @@ void GPUCommandEncoderImpl::BeginComputePass(const v8::FunctionCallbackInfo<v8::
 
     auto descVal = args[0];
 
-    CanvasGPUComputePass *pass;
+    const CanvasGPUComputePassEncoder *pass;
 
     if (!descVal->IsNullOrUndefined() && descVal->IsObject()) {
         auto desc = descVal.As<v8::Object>();
@@ -168,8 +168,8 @@ void GPUCommandEncoderImpl::BeginComputePass(const v8::FunctionCallbackInfo<v8::
 
 
     if (pass != nullptr) {
-        auto value = new GPUComputePassImpl(pass);
-        auto ret = GPUComputePassImpl::NewInstance(isolate, value);
+        auto value = new GPUComputePassEncoderImpl(pass);
+        auto ret = GPUComputePassEncoderImpl::NewInstance(isolate, value);
         args.GetReturnValue().Set(ret);
     } else {
         args.GetReturnValue().SetUndefined();
@@ -188,7 +188,9 @@ void GPUCommandEncoderImpl::BeginRenderPass(const v8::FunctionCallbackInfo<v8::V
 
     auto descVal = args[0];
 
-    CanvasGPURenderPass *pass = nullptr;
+    const CanvasGPURenderPassEncoder *pass = nullptr;
+
+    std::vector<CanvasRenderPassColorAttachment> colorAttachments_;
 
     if (!descVal->IsNullOrUndefined() && descVal->IsObject()) {
         auto desc = descVal.As<v8::Object>();
@@ -203,7 +205,7 @@ void GPUCommandEncoderImpl::BeginRenderPass(const v8::FunctionCallbackInfo<v8::V
             label = *v8::String::Utf8Value(isolate, labelVal);
         }
 
-        std::vector<CanvasRenderPassColorAttachment> colorAttachments_;
+
         v8::Local<v8::Value> colorAttachmentsVal;
         desc->Get(context, ConvertToV8String(isolate, "colorAttachments")).ToLocal(&colorAttachmentsVal);
 
@@ -256,7 +258,7 @@ void GPUCommandEncoderImpl::BeginRenderPass(const v8::FunctionCallbackInfo<v8::V
             auto view = GPUTextureViewImpl::GetPointer(viewVal.As<v8::Object>());
 
 
-            CanvasGPUTextureView *resolve_target = nullptr;
+            const CanvasGPUTextureView *resolve_target = nullptr;
 
             v8::Local<v8::Value> resolve_target_val;
 
@@ -268,16 +270,46 @@ void GPUCommandEncoderImpl::BeginRenderPass(const v8::FunctionCallbackInfo<v8::V
                 resolve_target = res->GetTextureView();
             }
 
+            // default
+            CanvasLoadOp load = CanvasLoadOp::CanvasLoadOpClear;
+            CanvasStoreOp store = CanvasStoreOp::CanvasStoreOpStore;
             auto loadVal = colorAttachment->Get(context, ConvertToV8String(isolate,
-                                                                           "loadOp")).ToLocalChecked()->Uint32Value(
-                    context).ToChecked();
+                                                                           "loadOp")).ToLocalChecked();
+
+            if(loadVal->IsUint32()){
+                load = (CanvasLoadOp)loadVal->Uint32Value(
+context).ToChecked();
+            }else if(loadVal->IsString()){
+                auto val = ConvertFromV8String(isolate, loadVal);
+                if(strcmp(val.c_str(), "clear") == 0){
+                    load = CanvasLoadOp::CanvasLoadOpClear;
+                }else if(strcmp(val.c_str(), "load") == 0){
+                    load = CanvasLoadOp::CanvasLoadOpLoad;
+                }
+            }
+
+
+
             auto storeVal = colorAttachment->Get(context, ConvertToV8String(isolate,
-                                                                            "storeOp")).ToLocalChecked()->Uint32Value(
-                    context).ToChecked();
+                                                                            "storeOp")).ToLocalChecked();
+
+            if(!storeVal.IsEmpty() && storeVal->IsUint32()){
+                store = (CanvasStoreOp)storeVal->Uint32Value(
+context).ToChecked();
+            }else if(storeVal->IsString()){
+                auto val = ConvertFromV8String(isolate, storeVal);
+                if(strcmp(val.c_str(), "discard") == 0){
+                    store = CanvasStoreOp::CanvasStoreOpDiscard;
+                }else if(strcmp(val.c_str(), "store") == 0){
+                    store = CanvasStoreOp::CanvasStoreOpStore;
+                }
+            }
 
             CanvasPassChannelColor channel{
-                    (CanvasLoadOp) loadVal,
-                    (CanvasStoreOp) storeVal
+                    load,
+                    store,
+                clearValue,
+                false
             };
 
             auto attachment = CanvasRenderPassColorAttachment{
@@ -397,10 +429,8 @@ void GPUCommandEncoderImpl::ClearBuffer(const v8::FunctionCallbackInfo<v8::Value
         return;
     }
 
-    auto isolate = args.GetIsolate();
-
     auto bufferVal = args[0];
-    CanvasGPUBuffer *buffer = nullptr;
+    const CanvasGPUBuffer *buffer = nullptr;
 
     if (bufferVal->IsObject()) {
         auto bufferPtr = GPUBufferImpl::GetPointer(bufferVal.As<v8::Object>());
@@ -445,16 +475,18 @@ void GPUCommandEncoderImpl::Finish(const v8::FunctionCallbackInfo<v8::Value> &ar
 
     auto descVal = args[0];
     std::string label;
+    bool didSet = false;
     if (descVal->IsObject()) {
         auto desc = descVal.As<v8::Object>();
         v8::Local<v8::Value> labelVal;
         desc->Get(context, ConvertToV8String(isolate, "label")).ToLocal(&labelVal);
         if (!labelVal.IsEmpty() && labelVal->IsString()) {
             label = ConvertFromV8String(isolate, labelVal);
+            didSet = true;
         }
     }
 
-    auto value = canvas_native_webgpu_command_encoder_finish(ptr->GetEncoder(), nullptr);
+    auto value = canvas_native_webgpu_command_encoder_finish(ptr->GetEncoder(), didSet ? label.c_str(): nullptr);
 
     if (value != nullptr) {
         auto ret = GPUCommandBufferImpl::NewInstance(isolate, new GPUCommandBufferImpl(value));
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCommandEncoderImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCommandEncoderImpl.h
index a70d322f5..57d5a5d89 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCommandEncoderImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUCommandEncoderImpl.h
@@ -10,12 +10,13 @@
 
 class GPUCommandEncoderImpl : ObjectWrapperImpl {
 public:
-    GPUCommandEncoderImpl(CanvasGPUCommandEncoder *encoder);
+    GPUCommandEncoderImpl(const CanvasGPUCommandEncoder *encoder);
 
     ~GPUCommandEncoderImpl() {
+        canvas_native_webgpu_command_encoder_release(this->GetEncoder());
     }
 
-    CanvasGPUCommandEncoder *GetEncoder();
+    const CanvasGPUCommandEncoder *GetEncoder();
 
     static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
 
@@ -43,7 +44,7 @@ class GPUCommandEncoderImpl : ObjectWrapperImpl {
     static void Finish(const v8::FunctionCallbackInfo<v8::Value> &args);
 
 private:
-    CanvasGPUCommandEncoder *encoder_;
+    const CanvasGPUCommandEncoder *encoder_;
 };
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUComputePassImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUComputePassEncoderImpl.cpp
similarity index 67%
rename from packages/canvas/platforms/ios/src/cpp/webgpu/GPUComputePassImpl.cpp
rename to packages/canvas/platforms/ios/src/cpp/webgpu/GPUComputePassEncoderImpl.cpp
index d778aab2f..a844ba9d6 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUComputePassImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUComputePassEncoderImpl.cpp
@@ -2,18 +2,18 @@
 // Created by Osei Fortune on 23/06/2024.
 //
 
-#include "GPUComputePassImpl.h"
+#include "GPUComputePassEncoderImpl.h"
 #include "Caches.h"
 
-GPUComputePassImpl::GPUComputePassImpl(CanvasGPUComputePass *pass) : computePass_(
+GPUComputePassEncoderImpl::GPUComputePassEncoderImpl(const CanvasGPUComputePassEncoder *pass) : computePass_(
         pass) {}
 
-CanvasGPUComputePass *GPUComputePassImpl::GetComputePass() {
+const CanvasGPUComputePassEncoder *GPUComputePassEncoderImpl::GetComputePass() {
     return this->computePass_;
 }
 
 
-void GPUComputePassImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate) {
+void GPUComputePassEncoderImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate) {
     v8::Locker locker(isolate);
     v8::Isolate::Scope isolate_scope(isolate);
     v8::HandleScope handle_scope(isolate);
@@ -25,15 +25,15 @@ void GPUComputePassImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolate *i
     canvasModule->Set(context, ConvertToV8String(isolate, "GPUComputePass"), func);
 }
 
-GPUComputePassImpl *GPUComputePassImpl::GetPointer(const v8::Local<v8::Object> &object) {
+GPUComputePassEncoderImpl *GPUComputePassEncoderImpl::GetPointer(const v8::Local<v8::Object> &object) {
     auto ptr = object->GetAlignedPointerFromInternalField(0);
     if (ptr == nullptr) {
         return nullptr;
     }
-    return static_cast<GPUComputePassImpl *>(ptr);
+    return static_cast<GPUComputePassEncoderImpl *>(ptr);
 }
 
-v8::Local<v8::FunctionTemplate> GPUComputePassImpl::GetCtor(v8::Isolate *isolate) {
+v8::Local<v8::FunctionTemplate> GPUComputePassEncoderImpl::GetCtor(v8::Isolate *isolate) {
     auto cache = Caches::Get(isolate);
     auto ctor = cache->GPUComputePassTmpl.get();
     if (ctor != nullptr) {
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUComputePassEncoderImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUComputePassEncoderImpl.h
new file mode 100644
index 000000000..f42a7d847
--- /dev/null
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUComputePassEncoderImpl.h
@@ -0,0 +1,45 @@
+//
+// Created by Osei Fortune on 23/06/2024.
+//
+
+#ifndef CANVAS_ANDROID_GPUCOMPUTEPASSENCODERIMPL_H
+#define CANVAS_ANDROID_GPUCOMPUTEPASSENCODERIMPL_H
+
+#include "Helpers.h"
+#include "ObjectWrapperImpl.h"
+
+class GPUComputePassEncoderImpl : ObjectWrapperImpl {
+public:
+    GPUComputePassEncoderImpl(const CanvasGPUComputePassEncoder *computePass);
+
+    ~GPUComputePassEncoderImpl() {
+        canvas_native_webgpu_compute_pass_release(this->GetComputePass());
+    }
+
+    const CanvasGPUComputePassEncoder *GetComputePass();
+
+    static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
+
+    static GPUComputePassEncoderImpl *GetPointer(const v8::Local<v8::Object> &object);
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
+
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, GPUComputePassEncoderImpl *pass) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = GPUComputePassEncoderImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(object, NativeType::GPUComputePass);
+        object->SetAlignedPointerInInternalField(0, pass);
+        pass->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
+
+
+private:
+    const CanvasGPUComputePassEncoder *computePass_;
+};
+
+
+#endif //CANVAS_ANDROID_GPUCOMPUTEPASSENCODERIMPL_H
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUComputePassImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUComputePassImpl.h
deleted file mode 100644
index 46b31aa2b..000000000
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUComputePassImpl.h
+++ /dev/null
@@ -1,43 +0,0 @@
-//
-// Created by Osei Fortune on 23/06/2024.
-//
-
-#ifndef CANVAS_ANDROID_GPUCOMPUTEPASSIMPL_H
-#define CANVAS_ANDROID_GPUCOMPUTEPASSIMPL_H
-
-#include "Helpers.h"
-#include "ObjectWrapperImpl.h"
-
-class GPUComputePassImpl : ObjectWrapperImpl {
-public:
-    GPUComputePassImpl(CanvasGPUComputePass *computePass);
-
-    ~GPUComputePassImpl() {
-    }
-
-    CanvasGPUComputePass *GetComputePass();
-
-    static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
-
-    static GPUComputePassImpl *GetPointer(const v8::Local<v8::Object> &object);
-
-    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
-
-    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, GPUComputePassImpl *pass) {
-        auto context = isolate->GetCurrentContext();
-        v8::EscapableHandleScope scope(isolate);
-        auto object = GPUComputePassImpl::GetCtor(isolate)->GetFunction(
-                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::GPUComputePass);
-        object->SetAlignedPointerInInternalField(0, pass);
-        pass->BindFinalizer(isolate, object);
-        return scope.Escape(object);
-    }
-
-
-private:
-    CanvasGPUComputePass *computePass_;
-};
-
-
-#endif //CANVAS_ANDROID_GPUCOMPUTEPASSIMPL_H
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUDeviceImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUDeviceImpl.cpp
index 97fd06240..ec3759594 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUDeviceImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUDeviceImpl.cpp
@@ -11,9 +11,9 @@
 #include "GPUPipelineLayoutImpl.h"
 #include "GPURenderPipelineImpl.h"
 
-GPUDeviceImpl::GPUDeviceImpl(CanvasGPUDevice *device) : device_(device) {}
+GPUDeviceImpl::GPUDeviceImpl(const CanvasGPUDevice *device) : device_(device) {}
 
-CanvasGPUDevice *GPUDeviceImpl::GetGPUDevice() {
+const CanvasGPUDevice *GPUDeviceImpl::GetGPUDevice() {
     return this->device_;
 }
 
@@ -102,7 +102,6 @@ v8::Local<v8::FunctionTemplate> GPUDeviceImpl::GetCtor(v8::Isolate *isolate) {
     return ctorTmpl;
 }
 
-
 void
 GPUDeviceImpl::GetFeatures(v8::Local<v8::Name> name,
                            const v8::PropertyCallbackInfo<v8::Value> &info) {
@@ -258,9 +257,6 @@ void GPUDeviceImpl::CreateBuffer(const v8::FunctionCallbackInfo<v8::Value> &args
     uint64_t size = 0;
     uint32_t usage = 0;
 
-    char *error = nullptr;
-
-
     auto optionsVal = args[0];
 
     if (optionsVal->IsObject()) {
@@ -298,7 +294,7 @@ void GPUDeviceImpl::CreateBuffer(const v8::FunctionCallbackInfo<v8::Value> &args
     }
 
     auto buffer = canvas_native_webgpu_device_create_buffer(ptr->GetGPUDevice(), label, size, usage,
-                                                            mappedAtCreation, error);
+                                                            mappedAtCreation);
 
     if (buffer != nullptr) {
         auto bufImpl = new GPUBufferImpl(buffer);
@@ -306,10 +302,7 @@ void GPUDeviceImpl::CreateBuffer(const v8::FunctionCallbackInfo<v8::Value> &args
         args.GetReturnValue().Set(ret);
 
     } else {
-        if (error != nullptr) {
-            isolate->ThrowError(ConvertToV8String(isolate, error));
-        }
-
+        // todo return invalid buffer
         args.GetReturnValue().SetUndefined();
     }
 }
@@ -461,8 +454,7 @@ void GPUDeviceImpl::CreateTexture(const v8::FunctionCallbackInfo<v8::Value> &arg
 
     }
 
-    auto texture = canvas_native_webgpu_device_create_texture(ptr->GetGPUDevice(), &descriptor,
-                                                              error);
+    auto texture = canvas_native_webgpu_device_create_texture(ptr->GetGPUDevice(), &descriptor);
 
     if (texture != nullptr) {
         auto textureImpl = new GPUTextureImpl(texture);
@@ -491,10 +483,8 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
 
     char *error = nullptr;
 
-
     auto optionsVal = args[0];
 
-
     if (!optionsVal->IsObject()) {
         // should error at this point
         return;
@@ -545,7 +535,7 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
     std::vector<CanvasColorTargetState> targets;
 
     if (!fragmentValue.IsEmpty() && fragmentValue->IsObject()) {
-        auto fragmentValueObj = fragmentValue.As<v8::Object>();
+          auto fragmentValueObj = fragmentValue.As<v8::Object>();
         fragment = new CanvasFragmentState{};
 
         v8::Local<v8::Value> targetsVal;
@@ -670,12 +660,12 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
         if (!constantsVal.IsEmpty() && constantsVal->IsMap()) {
             auto constants = constantsVal.As<v8::Map>();
             auto keyValues = constants->AsArray();
-            auto len = keyValues->Length();
+            auto length = keyValues->Length();
             CanvasConstants *store = nullptr;
 
-            if (len > 0) {
+            if (length > 0) {
                 store = canvas_native_webgpu_constants_create();
-                for (int i = 0; i < len; i += 2) {
+                for (int i = 0; i < length; i += 2) {
                     auto k = i;
                     auto v = k + 1;
 
@@ -744,7 +734,7 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
 
     if (layoutVal->IsString()) {
         layout = CanvasGPUPipelineLayoutOrGPUAutoLayoutMode{
-                CanvasGPUPipelineLayoutOrGPUAutoLayoutModeAuto
+            CanvasGPUPipelineLayoutOrGPUAutoLayoutModeAuto
         };
     } else {
         auto pipeline = GPUPipelineLayoutImpl::GetPointer(layoutVal.As<v8::Object>());
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUDeviceImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUDeviceImpl.h
index aff9aa1a4..c530812e9 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUDeviceImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUDeviceImpl.h
@@ -13,16 +13,13 @@
 
 class GPUDeviceImpl : ObjectWrapperImpl {
 public:
-    GPUDeviceImpl(CanvasGPUDevice *device);
+    GPUDeviceImpl(const CanvasGPUDevice *device);
 
     ~GPUDeviceImpl() {
-        if(this->device_ != nullptr){
-            canvas_native_webgpu_device_destroy_destory(this->device_);
-            this->device_ = nullptr;
-        }
+        canvas_native_webgpu_device_release(this->device_);
     }
 
-    CanvasGPUDevice *GetGPUDevice();
+    const CanvasGPUDevice *GetGPUDevice();
 
     static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
 
@@ -43,13 +40,13 @@ class GPUDeviceImpl : ObjectWrapperImpl {
 
 
     static void GetFeatures(v8::Local<v8::Name> name,
-                               const v8::PropertyCallbackInfo<v8::Value> &info);
+                            const v8::PropertyCallbackInfo<v8::Value> &info);
 
     static void GetLimits(v8::Local<v8::Name> name,
-                            const v8::PropertyCallbackInfo<v8::Value> &info);
+                          const v8::PropertyCallbackInfo<v8::Value> &info);
 
     static void GetQueue(v8::Local<v8::Name> name,
-                            const v8::PropertyCallbackInfo<v8::Value> &info);
+                         const v8::PropertyCallbackInfo<v8::Value> &info);
 
     static void GetLost(v8::Local<v8::Name> name,
                         const v8::PropertyCallbackInfo<v8::Value> &info);
@@ -68,7 +65,7 @@ class GPUDeviceImpl : ObjectWrapperImpl {
 
 
 private:
-    CanvasGPUDevice *device_;
+    const CanvasGPUDevice *device_;
 };
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUImpl.cpp
index 58888d50d..1a0414e77 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUImpl.cpp
@@ -5,9 +5,9 @@
 #include "GPUImpl.h"
 #include "Caches.h"
 
-GPUImpl::GPUImpl(CanvasWebGPUInstance *instance) : instance_(instance) {}
+GPUImpl::GPUImpl(const CanvasWebGPUInstance *instance) : instance_(instance) {}
 
-CanvasWebGPUInstance *GPUImpl::GetGPUInstance() {
+const CanvasWebGPUInstance *GPUImpl::GetGPUInstance() {
     return this->instance_;
 }
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUImpl.h
index ef4323ebd..4fe1590f1 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUImpl.h
@@ -12,16 +12,16 @@
 
 class GPUImpl : ObjectWrapperImpl {
 public:
-    GPUImpl(CanvasWebGPUInstance *instance);
+    GPUImpl(const CanvasWebGPUInstance *instance);
 
     ~GPUImpl() {
         if (this->instance_ != nullptr) {
-            canvas_native_webgpu_instance_destroy(this->instance_);
+            canvas_native_webgpu_instance_release(this->instance_);
             this->instance_ = nullptr;
         }
     }
 
-    CanvasWebGPUInstance *GetGPUInstance();
+    const CanvasWebGPUInstance *GetGPUInstance();
 
     static void Init(const v8::Local<v8::Object> &canvasModule, v8::Isolate *isolate);
 
@@ -48,7 +48,7 @@ class GPUImpl : ObjectWrapperImpl {
     static void RequestAdapter(const v8::FunctionCallbackInfo<v8::Value> &args);
 
 private:
-    CanvasWebGPUInstance *instance_;
+    const CanvasWebGPUInstance *instance_;
 };
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUQueueImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUQueueImpl.cpp
index bbf72513d..3a1066abc 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUQueueImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUQueueImpl.cpp
@@ -7,9 +7,9 @@
 #include "GPUBufferImpl.h"
 #include "GPUCommandBufferImpl.h"
 
-GPUQueueImpl::GPUQueueImpl(CanvasGPUQueue *queue) : queue_(queue) {}
+GPUQueueImpl::GPUQueueImpl(const CanvasGPUQueue *queue) : queue_(queue) {}
 
-CanvasGPUQueue *GPUQueueImpl::GetGPUQueue() {
+const CanvasGPUQueue *GPUQueueImpl::GetGPUQueue() {
     return this->queue_;
 }
 
@@ -87,7 +87,7 @@ void GPUQueueImpl::WriteBuffer(const v8::FunctionCallbackInfo<v8::Value> &args)
 
         auto data = static_cast<uint8_t *>(store->Data()) + offset;
 
-        auto data_size = store->ByteLength() - offset;
+        auto data_size = store->ByteLength();
 
         auto dataOffset = (uint64_t) args[3].As<v8::Number>()->Value();
 
@@ -119,7 +119,7 @@ void GPUQueueImpl::Submit(const v8::FunctionCallbackInfo<v8::Value> &args) {
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    std::vector<CanvasGPUCommandBuffer *> commandBuffers;
+    std::vector<const CanvasGPUCommandBuffer *> commandBuffers;
     auto commandBuffersVal = args[0];
 
     if (commandBuffersVal->IsArray()) {
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUQueueImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUQueueImpl.h
index e4ff60beb..cf4f10c4f 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUQueueImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUQueueImpl.h
@@ -9,14 +9,14 @@
 #include "Helpers.h"
 #include "ObjectWrapperImpl.h"
 
-class GPUQueueImpl: ObjectWrapperImpl  {
+class GPUQueueImpl : ObjectWrapperImpl {
 public:
-    GPUQueueImpl(CanvasGPUQueue *queue);
+    GPUQueueImpl(const CanvasGPUQueue *queue);
 
     ~GPUQueueImpl() {
     }
 
-    CanvasGPUQueue *GetGPUQueue();
+    const CanvasGPUQueue *GetGPUQueue();
 
     static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
 
@@ -42,7 +42,7 @@ class GPUQueueImpl: ObjectWrapperImpl  {
 
 
 private:
-    CanvasGPUQueue *queue_;
+    const CanvasGPUQueue *queue_;
 };
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderPassEncoderImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderPassEncoderImpl.cpp
index 80693a99d..73cb5436f 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderPassEncoderImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderPassEncoderImpl.cpp
@@ -7,9 +7,9 @@
 #include "GPURenderPipelineImpl.h"
 #include "GPUBufferImpl.h"
 
-GPURenderPassEncoderImpl::GPURenderPassEncoderImpl(CanvasGPURenderPass *pass) : pass_(pass) {}
+GPURenderPassEncoderImpl::GPURenderPassEncoderImpl(const CanvasGPURenderPassEncoder *pass) : pass_(pass) {}
 
-CanvasGPURenderPass *GPURenderPassEncoderImpl::GetPass() {
+const CanvasGPURenderPassEncoder *GPURenderPassEncoderImpl::GetPass() {
     return this->pass_;
 }
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderPassEncoderImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderPassEncoderImpl.h
index ebef63902..74f8cc9ed 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderPassEncoderImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderPassEncoderImpl.h
@@ -11,12 +11,13 @@
 
 class GPURenderPassEncoderImpl : ObjectWrapperImpl {
 public:
-    GPURenderPassEncoderImpl(CanvasGPURenderPass *pass);
+    GPURenderPassEncoderImpl(const CanvasGPURenderPassEncoder *pass);
 
     ~GPURenderPassEncoderImpl() {
+        canvas_native_webgpu_render_pass_release(this->GetPass());
     }
 
-    CanvasGPURenderPass *GetPass();
+    const CanvasGPURenderPassEncoder *GetPass();
 
     static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
 
@@ -47,7 +48,7 @@ class GPURenderPassEncoderImpl : ObjectWrapperImpl {
 
 
 private:
-    CanvasGPURenderPass *pass_;
+    const CanvasGPURenderPassEncoder *pass_;
 };
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderPipelineImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderPipelineImpl.cpp
index 928e7b660..772847bd0 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderPipelineImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderPipelineImpl.cpp
@@ -6,10 +6,10 @@
 #include "Caches.h"
 #include "GPUBindGroupLayoutImpl.h"
 
-GPURenderPipelineImpl::GPURenderPipelineImpl(CanvasGPURenderPipeline *pipeline) : pipeline_(
+GPURenderPipelineImpl::GPURenderPipelineImpl(const CanvasGPURenderPipeline *pipeline) : pipeline_(
         pipeline) {}
 
-CanvasGPURenderPipeline *GPURenderPipelineImpl::GetGPUPipeline() {
+const CanvasGPURenderPipeline *GPURenderPipelineImpl::GetGPUPipeline() {
     return this->pipeline_;
 }
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderPipelineImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderPipelineImpl.h
index 8af502ee6..5c51cfa84 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderPipelineImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPURenderPipelineImpl.h
@@ -11,12 +11,12 @@
 
 class GPURenderPipelineImpl : ObjectWrapperImpl {
 public:
-    GPURenderPipelineImpl(CanvasGPURenderPipeline *pipeline);
+    GPURenderPipelineImpl(const CanvasGPURenderPipeline *pipeline);
 
     ~GPURenderPipelineImpl() {
     }
 
-    CanvasGPURenderPipeline *GetGPUPipeline();
+    const CanvasGPURenderPipeline *GetGPUPipeline();
 
     static void Init(v8::Local <v8::Object> canvasModule, v8::Isolate *isolate);
 
@@ -41,7 +41,7 @@ class GPURenderPipelineImpl : ObjectWrapperImpl {
 
 
 private:
-    CanvasGPURenderPipeline *pipeline_;
+    const CanvasGPURenderPipeline *pipeline_;
 };
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUShaderModuleImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUShaderModuleImpl.cpp
index 4fbe442d7..0527b73f0 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUShaderModuleImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUShaderModuleImpl.cpp
@@ -5,10 +5,10 @@
 #include "GPUShaderModuleImpl.h"
 #include "Caches.h"
 
-GPUShaderModuleImpl::GPUShaderModuleImpl(CanvasGPUShaderModule *shaderModule) : shaderModule_(
+GPUShaderModuleImpl::GPUShaderModuleImpl(const CanvasGPUShaderModule *shaderModule) : shaderModule_(
         shaderModule) {}
 
-CanvasGPUShaderModule *GPUShaderModuleImpl::GetShaderModule() {
+const CanvasGPUShaderModule *GPUShaderModuleImpl::GetShaderModule() {
     return this->shaderModule_;
 }
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUShaderModuleImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUShaderModuleImpl.h
index 14328cb50..ded6f9ced 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUShaderModuleImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUShaderModuleImpl.h
@@ -11,12 +11,12 @@
 
 class GPUShaderModuleImpl : ObjectWrapperImpl {
 public:
-    GPUShaderModuleImpl(CanvasGPUShaderModule *shaderModule);
+    GPUShaderModuleImpl(const CanvasGPUShaderModule *shaderModule);
 
     ~GPUShaderModuleImpl() {
     }
 
-    CanvasGPUShaderModule *GetShaderModule();
+    const CanvasGPUShaderModule *GetShaderModule();
 
     static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
 
@@ -37,7 +37,7 @@ class GPUShaderModuleImpl : ObjectWrapperImpl {
     }
 
 private:
-    CanvasGPUShaderModule *shaderModule_;
+    const CanvasGPUShaderModule *shaderModule_;
 };
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUSupportedLimitsImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUSupportedLimitsImpl.h
index 36faf3945..b7f7dcc5f 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUSupportedLimitsImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUSupportedLimitsImpl.h
@@ -13,11 +13,7 @@ class GPUSupportedLimitsImpl : public ObjectWrapperImpl {
     GPUSupportedLimitsImpl(CanvasGPUSupportedLimits *limits);
 
     ~GPUSupportedLimitsImpl() {
-        if(this->limits_ == nullptr){
-            return;
-        }
-        canvas_native_webgpu_limits_destroy(this->limits_);
-        this->limits_ = nullptr;
+        canvas_native_webgpu_limits_release(this->limits_);
     }
 
     CanvasGPUSupportedLimits *GetLimits();
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUTextureImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUTextureImpl.cpp
index 9bbab8b4c..e20e2c8f3 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUTextureImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUTextureImpl.cpp
@@ -6,9 +6,9 @@
 #include "Caches.h"
 #include "GPUTextureViewImpl.h"
 
-GPUTextureImpl::GPUTextureImpl(CanvasGPUTexture *texture) : texture_(texture) {}
+GPUTextureImpl::GPUTextureImpl(const CanvasGPUTexture *texture) : texture_(texture) {}
 
-CanvasGPUTexture *GPUTextureImpl::GetTexture() {
+const CanvasGPUTexture *GPUTextureImpl::GetTexture() {
     return this->texture_;
 }
 
@@ -64,6 +64,10 @@ v8::Local<v8::FunctionTemplate> GPUTextureImpl::GetCtor(v8::Isolate *isolate) {
             GetHeight
     );
 
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "format"),
+            GetFormat
+    );
 
     tmpl->SetLazyDataProperty(
             ConvertToV8String(isolate, "usage"),
@@ -93,12 +97,12 @@ v8::Local<v8::FunctionTemplate> GPUTextureImpl::GetCtor(v8::Isolate *isolate) {
             ConvertToV8String(isolate, "mipLevelCount"),
             GetMipLevelCount
     );
-    
+
     tmpl->Set(
             ConvertToV8String(isolate, "createView"),
             v8::FunctionTemplate::New(isolate, &CreateView));
 
-    
+
     cache->GPUTextureTmpl =
             std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
     return ctorTmpl;
@@ -234,20 +238,20 @@ void GPUTextureImpl::CreateView(const v8::FunctionCallbackInfo<v8::Value> &args)
         return;
     }
     auto isolate = args.GetIsolate();
-    
+
     auto desc = args[0];
     CanvasCreateTextureViewDescriptor *descriptor = nullptr;
     if(desc->IsObject()){
-        
+
     }
     auto view = canvas_native_webgpu_texture_create_texture_view(ptr->GetTexture(), descriptor);
-    
+
     if(view != nullptr){
         auto ret = GPUTextureViewImpl::NewInstance(isolate, new GPUTextureViewImpl(view));
         args.GetReturnValue().Set(ret);
         return;
     }
-    
+
     args.GetReturnValue().SetUndefined();
-    
+
 }
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUTextureImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUTextureImpl.h
index 8c987a6d8..75c06328a 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUTextureImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUTextureImpl.h
@@ -11,12 +11,12 @@
 
 class GPUTextureImpl : ObjectWrapperImpl {
 public:
-    GPUTextureImpl(CanvasGPUTexture *texture);
+    GPUTextureImpl(const CanvasGPUTexture *texture);
 
     ~GPUTextureImpl() {
     }
 
-    CanvasGPUTexture *GetTexture();
+    const CanvasGPUTexture *GetTexture();
 
     static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
 
@@ -63,11 +63,11 @@ class GPUTextureImpl : ObjectWrapperImpl {
                                const v8::PropertyCallbackInfo<v8::Value> &info);
 
     static void Destroy(const v8::FunctionCallbackInfo<v8::Value> &args);
-    
+
     static void CreateView(const v8::FunctionCallbackInfo<v8::Value> &args);
 
 private:
-    CanvasGPUTexture *texture_;
+    const CanvasGPUTexture *texture_;
 };
 
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUTextureViewImpl.cpp b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUTextureViewImpl.cpp
index fe38f39de..fa5cf9e82 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUTextureViewImpl.cpp
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUTextureViewImpl.cpp
@@ -5,9 +5,9 @@
 #include "GPUTextureViewImpl.h"
 #include "Caches.h"
 
-GPUTextureViewImpl::GPUTextureViewImpl(CanvasGPUTextureView *view) : view_(view) {}
+GPUTextureViewImpl::GPUTextureViewImpl(const CanvasGPUTextureView *view) : view_(view) {}
 
-CanvasGPUTextureView *GPUTextureViewImpl::GetTextureView() {
+const CanvasGPUTextureView *GPUTextureViewImpl::GetTextureView() {
     return this->view_;
 }
 
diff --git a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUTextureViewImpl.h b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUTextureViewImpl.h
index 56ca656fe..380166526 100644
--- a/packages/canvas/platforms/ios/src/cpp/webgpu/GPUTextureViewImpl.h
+++ b/packages/canvas/platforms/ios/src/cpp/webgpu/GPUTextureViewImpl.h
@@ -11,12 +11,13 @@
 
 class GPUTextureViewImpl : ObjectWrapperImpl {
 public:
-    GPUTextureViewImpl(CanvasGPUTextureView *view);
+    GPUTextureViewImpl(const CanvasGPUTextureView *view);
 
     ~GPUTextureViewImpl() {
+        canvas_native_webgpu_texture_view_release(this->GetTextureView());
     }
 
-    CanvasGPUTextureView *GetTextureView();
+    const CanvasGPUTextureView *GetTextureView();
 
     static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
 
@@ -37,7 +38,7 @@ class GPUTextureViewImpl : ObjectWrapperImpl {
 
 
 private:
-    CanvasGPUTextureView *view_;
+    const CanvasGPUTextureView *view_;
 };
 
 
diff --git a/packages/canvas/src-native/canvas-android/.idea/dictionaries/triniwiz.xml b/packages/canvas/src-native/canvas-android/.idea/dictionaries/triniwiz.xml
index dcdb04829..26029c473 100644
--- a/packages/canvas/src-native/canvas-android/.idea/dictionaries/triniwiz.xml
+++ b/packages/canvas/src-native/canvas-android/.idea/dictionaries/triniwiz.xml
@@ -19,6 +19,7 @@
       <w>parameterf</w>
       <w>parameteri</w>
       <w>pname</w>
+      <w>postmultiplied</w>
       <w>premultiplied</w>
       <w>premultiply</w>
       <w>primcount</w>
diff --git a/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/include/canvas_native.h b/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/include/canvas_native.h
index b299e05f8..bdf2fa39e 100644
--- a/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/include/canvas_native.h
+++ b/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/include/canvas_native.h
@@ -8,6 +8,38 @@
 #include <stdint.h>
 #include <stdlib.h>
 
+typedef enum CanvasAddressMode {
+  /**
+   * Clamp the value to the edge of the texture
+   *
+   * -0.25 -> 0.0
+   * 1.25  -> 1.0
+   */
+  CanvasAddressModeClampToEdge = 0,
+  /**
+   * Repeat the texture in a tiling fashion
+   *
+   * -0.25 -> 0.75
+   * 1.25 -> 0.25
+   */
+  CanvasAddressModeRepeat = 1,
+  /**
+   * Repeat the texture, mirroring it every repeat
+   *
+   * -0.25 -> 0.25
+   * 1.25 -> 0.75
+   */
+  CanvasAddressModeMirrorRepeat = 2,
+  /**
+   * Clamp the value to the border of the texture
+   * Requires feature [`Features::ADDRESS_MODE_CLAMP_TO_BORDER`]
+   *
+   * -0.25 -> border
+   * 1.25 -> border
+   */
+  CanvasAddressModeClampToBorder = 3,
+} CanvasAddressMode;
+
 /**
  * ASTC block dimensions
  */
@@ -188,6 +220,12 @@ typedef enum CanvasBlendOperation {
   CanvasBlendOperationMax = 4,
 } CanvasBlendOperation;
 
+typedef enum CanvasBufferBindingType {
+  CanvasBufferBindingTypeUniform,
+  CanvasBufferBindingTypeStorage,
+  CanvasBufferBindingTypeReadOnlyStorage,
+} CanvasBufferBindingType;
+
 typedef enum CanvasCompareFunction {
   CanvasCompareFunctionNever = 1,
   CanvasCompareFunctionLess = 2,
@@ -205,6 +243,16 @@ typedef enum CanvasCullMode {
   CanvasCullModeBack,
 } CanvasCullMode;
 
+typedef enum CanvasFilterMode {
+  CanvasFilterModeNearest = 0,
+  /**
+   * Linear Interpolation
+   *
+   * This makes textures smooth but blurry when used as a mag filter.
+   */
+  CanvasFilterModeLinear = 1,
+} CanvasFilterMode;
+
 typedef enum CanvasFrontFace {
   CanvasFrontFaceCcw = 0,
   CanvasFrontFaceCw = 1,
@@ -214,6 +262,14 @@ typedef enum CanvasGPUAutoLayoutMode {
   CanvasGPUAutoLayoutModeAuto,
 } CanvasGPUAutoLayoutMode;
 
+typedef enum CanvasGPUErrorType {
+  CanvasGPUErrorTypeNone,
+  CanvasGPUErrorTypeLost,
+  CanvasGPUErrorTypeOutOfMemory,
+  CanvasGPUErrorTypeValidation,
+  CanvasGPUErrorTypeInternal,
+} CanvasGPUErrorType;
+
 typedef enum CanvasGPUPowerPreference {
   CanvasGPUPowerPreferenceNone,
   CanvasGPUPowerPreferenceLowPower,
@@ -271,6 +327,28 @@ typedef enum CanvasPrimitiveTopology {
   CanvasPrimitiveTopologyTriangleStrip = 4,
 } CanvasPrimitiveTopology;
 
+typedef enum CanvasQueryType {
+  CanvasQueryTypeOcclusion,
+  CanvasQueryTypeTimestamp,
+} CanvasQueryType;
+
+typedef enum CanvasSamplerBindingType {
+  /**
+   * The sampling result is produced based on more than a single color sample from a texture,
+   * e.g. when bilinear interpolation is enabled.
+   */
+  CanvasSamplerBindingTypeFiltering,
+  /**
+   * The sampling result is produced based on a single color sample from a texture.
+   */
+  CanvasSamplerBindingTypeNonFiltering,
+  /**
+   * Use as a comparison sampler instead of a normal sampler.
+   * For more info take a look at the analogous functionality in OpenGL: <https://www.khronos.org/opengl/wiki/Sampler_Object#Comparison_mode>.
+   */
+  CanvasSamplerBindingTypeComparison,
+} CanvasSamplerBindingType;
+
 typedef enum CanvasStencilOperation {
   CanvasStencilOperationKeep = 0,
   CanvasStencilOperationZero = 1,
@@ -282,6 +360,64 @@ typedef enum CanvasStencilOperation {
   CanvasStencilOperationDecrementWrap = 7,
 } CanvasStencilOperation;
 
+typedef enum CanvasStorageTextureAccess {
+  /**
+   * The texture can only be written in the shader and it:
+   * - may or may not be annotated with `write` (WGSL).
+   * - must be annotated with `writeonly` (GLSL).
+   *
+   * Example WGSL syntax:
+   * ```rust,ignore
+   * @group(0) @binding(0)
+   * var my_storage_image: texture_storage_2d<f32, write>;
+   * ```
+   *
+   * Example GLSL syntax:
+   * ```cpp,ignore
+   * layout(set=0, binding=0, r32f) writeonly uniform image2D myStorageImage;
+   * ```
+   */
+  CanvasStorageTextureAccessWriteOnly,
+  /**
+   * The texture can only be read in the shader and it must be annotated with `read` (WGSL) or
+   * `readonly` (GLSL).
+   *
+   * [`Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES`] must be enabled to use this access
+   * mode. This is a native-only extension.
+   *
+   * Example WGSL syntax:
+   * ```rust,ignore
+   * @group(0) @binding(0)
+   * var my_storage_image: texture_storage_2d<f32, read>;
+   * ```
+   *
+   * Example GLSL syntax:
+   * ```cpp,ignore
+   * layout(set=0, binding=0, r32f) readonly uniform image2D myStorageImage;
+   * ```
+   */
+  CanvasStorageTextureAccessReadOnly,
+  /**
+   * The texture can be both read and written in the shader and must be annotated with
+   * `read_write` in WGSL.
+   *
+   * [`Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES`] must be enabled to use this access
+   * mode.  This is a nonstandard, native-only extension.
+   *
+   * Example WGSL syntax:
+   * ```rust,ignore
+   * @group(0) @binding(0)
+   * var my_storage_image: texture_storage_2d<f32, read_write>;
+   * ```
+   *
+   * Example GLSL syntax:
+   * ```cpp,ignore
+   * layout(set=0, binding=0, r32f) uniform image2D myStorageImage;
+   * ```
+   */
+  CanvasStorageTextureAccessReadWrite,
+} CanvasStorageTextureAccess;
+
 typedef enum CanvasStoreOp {
   CanvasStoreOpDiscard = 0,
   CanvasStoreOpStore = 1,
@@ -320,6 +456,23 @@ typedef enum CanvasTextureDimension {
   CanvasTextureDimensionD3,
 } CanvasTextureDimension;
 
+typedef enum CanvasTextureSampleType {
+  CanvasTextureSampleTypeFloat,
+  CanvasTextureSampleTypeUnfilterableFloat,
+  CanvasTextureSampleTypeDepth,
+  CanvasTextureSampleTypeSint,
+  CanvasTextureSampleTypeUint,
+} CanvasTextureSampleType;
+
+typedef enum CanvasTextureViewDimension {
+  CanvasTextureViewDimensionD1,
+  CanvasTextureViewDimensionD2,
+  CanvasTextureViewDimensionD2Array,
+  CanvasTextureViewDimensionCube,
+  CanvasTextureViewDimensionCubeArray,
+  CanvasTextureViewDimensionD3,
+} CanvasTextureViewDimension;
+
 typedef enum CanvasVertexFormat {
   CanvasVertexFormatUint8x2 = 0,
   CanvasVertexFormatUint8x4 = 1,
@@ -478,10 +631,14 @@ typedef struct CanvasGPUCommandBuffer CanvasGPUCommandBuffer;
 
 typedef struct CanvasGPUCommandEncoder CanvasGPUCommandEncoder;
 
-typedef struct CanvasGPUComputePass CanvasGPUComputePass;
+typedef struct CanvasGPUComputePassEncoder CanvasGPUComputePassEncoder;
+
+typedef struct CanvasGPUComputePipeline CanvasGPUComputePipeline;
 
 typedef struct CanvasGPUDevice CanvasGPUDevice;
 
+typedef struct CanvasGPUError CanvasGPUError;
+
 typedef struct CanvasGPUPipelineLayout CanvasGPUPipelineLayout;
 
 typedef struct CanvasGPUQuerySet CanvasGPUQuerySet;
@@ -490,10 +647,14 @@ typedef struct CanvasGPUQueue CanvasGPUQueue;
 
 typedef struct CanvasGPURenderBundle CanvasGPURenderBundle;
 
-typedef struct CanvasGPURenderPass CanvasGPURenderPass;
+typedef struct CanvasGPURenderBundleEncoder CanvasGPURenderBundleEncoder;
+
+typedef struct CanvasGPURenderPassEncoder CanvasGPURenderPassEncoder;
 
 typedef struct CanvasGPURenderPipeline CanvasGPURenderPipeline;
 
+typedef struct CanvasGPUSampler CanvasGPUSampler;
+
 typedef struct CanvasGPUShaderModule CanvasGPUShaderModule;
 
 typedef struct CanvasGPUTexture CanvasGPUTexture;
@@ -726,65 +887,21 @@ typedef struct CanvasExtent3d {
   uint32_t depth_or_array_layers;
 } CanvasExtent3d;
 
-typedef enum CanvasGPUPipelineLayoutOrGPUAutoLayoutMode_Tag {
-  CanvasGPUPipelineLayoutOrGPUAutoLayoutModeLayout,
-  CanvasGPUPipelineLayoutOrGPUAutoLayoutModeAuto,
-} CanvasGPUPipelineLayoutOrGPUAutoLayoutMode_Tag;
+typedef struct CanvasBufferBindingLayout {
+  enum CanvasBufferBindingType type_;
+  bool has_dynamic_offset;
+  int64_t min_binding_size;
+} CanvasBufferBindingLayout;
 
-typedef struct CanvasGPUPipelineLayoutOrGPUAutoLayoutMode {
-  CanvasGPUPipelineLayoutOrGPUAutoLayoutMode_Tag tag;
-  union {
-    struct {
-      const struct CanvasGPUPipelineLayout *layout;
-    };
-    struct {
-      enum CanvasGPUAutoLayoutMode auto_;
-    };
-  };
-} CanvasGPUPipelineLayoutOrGPUAutoLayoutMode;
-
-typedef struct CanvasVertexAttribute {
-  enum CanvasVertexFormat format;
-  uint64_t offset;
-  uint32_t shader_location;
-} CanvasVertexAttribute;
-
-typedef struct CanvasVertexBufferLayout {
-  uint64_t array_stride;
-  enum CanvasVertexStepMode step_mode;
-  const struct CanvasVertexAttribute *attributes;
-  uintptr_t attributes_size;
-} CanvasVertexBufferLayout;
+typedef struct CanvasSamplerBindingLayout {
+  enum CanvasSamplerBindingType type_;
+} CanvasSamplerBindingLayout;
 
-typedef struct CanvasVertexState {
-  const struct CanvasGPUShaderModule *module;
-  const char *entry_point;
-  const struct CanvasConstants *constants;
-  const struct CanvasVertexBufferLayout *buffers;
-  uintptr_t buffers_size;
-} CanvasVertexState;
-
-typedef enum CanvasOptionalIndexFormat_Tag {
-  CanvasOptionalIndexFormatNone,
-  CanvasOptionalIndexFormatSome,
-} CanvasOptionalIndexFormat_Tag;
-
-typedef struct CanvasOptionalIndexFormat {
-  CanvasOptionalIndexFormat_Tag tag;
-  union {
-    struct {
-      enum CanvasIndexFormat some;
-    };
-  };
-} CanvasOptionalIndexFormat;
-
-typedef struct CanvasPrimitiveState {
-  enum CanvasPrimitiveTopology topology;
-  struct CanvasOptionalIndexFormat strip_index_format;
-  enum CanvasFrontFace front_face;
-  enum CanvasCullMode cull_mode;
-  bool unclipped_depth;
-} CanvasPrimitiveState;
+typedef struct CanvasTextureBindingLayout {
+  enum CanvasTextureSampleType sample_type;
+  enum CanvasTextureViewDimension view_dimension;
+  bool multisampled;
+} CanvasTextureBindingLayout;
 
 typedef enum CanvasGPUTextureFormat_Tag {
   /**
@@ -1237,6 +1354,151 @@ typedef struct CanvasGPUTextureFormat {
   };
 } CanvasGPUTextureFormat;
 
+typedef struct CanvasStorageTextureBindingLayout {
+  enum CanvasStorageTextureAccess access;
+  struct CanvasGPUTextureFormat format;
+  enum CanvasTextureViewDimension view_dimension;
+} CanvasStorageTextureBindingLayout;
+
+typedef enum CanvasBindingType_Tag {
+  CanvasBindingTypeBuffer,
+  CanvasBindingTypeSampler,
+  CanvasBindingTypeTexture,
+  CanvasBindingTypeStorageTexture,
+} CanvasBindingType_Tag;
+
+typedef struct CanvasBindingType {
+  CanvasBindingType_Tag tag;
+  union {
+    struct {
+      struct CanvasBufferBindingLayout buffer;
+    };
+    struct {
+      struct CanvasSamplerBindingLayout sampler;
+    };
+    struct {
+      struct CanvasTextureBindingLayout texture;
+    };
+    struct {
+      struct CanvasStorageTextureBindingLayout storage_texture;
+    };
+  };
+} CanvasBindingType;
+
+typedef struct CanvasBindGroupLayoutEntry {
+  uint32_t binding;
+  uint32_t visibility;
+  struct CanvasBindingType binding_type;
+} CanvasBindGroupLayoutEntry;
+
+typedef struct CanvasBufferBinding {
+  const struct CanvasGPUBuffer *buffer;
+  int64_t offset;
+  int64_t size;
+} CanvasBufferBinding;
+
+typedef enum CanvasBindGroupEntryResource_Tag {
+  CanvasBindGroupEntryResourceBuffer,
+  CanvasBindGroupEntryResourceSampler,
+  CanvasBindGroupEntryResourceTextureView,
+} CanvasBindGroupEntryResource_Tag;
+
+typedef struct CanvasBindGroupEntryResource {
+  CanvasBindGroupEntryResource_Tag tag;
+  union {
+    struct {
+      struct CanvasBufferBinding buffer;
+    };
+    struct {
+      const struct CanvasGPUSampler *sampler;
+    };
+    struct {
+      const struct CanvasGPUTextureView *texture_view;
+    };
+  };
+} CanvasBindGroupEntryResource;
+
+typedef struct CanvasBindGroupEntry {
+  uint32_t binding;
+  struct CanvasBindGroupEntryResource resource;
+} CanvasBindGroupEntry;
+
+typedef enum CanvasGPUPipelineLayoutOrGPUAutoLayoutMode_Tag {
+  CanvasGPUPipelineLayoutOrGPUAutoLayoutModeLayout,
+  CanvasGPUPipelineLayoutOrGPUAutoLayoutModeAuto,
+} CanvasGPUPipelineLayoutOrGPUAutoLayoutMode_Tag;
+
+typedef struct CanvasGPUPipelineLayoutOrGPUAutoLayoutMode {
+  CanvasGPUPipelineLayoutOrGPUAutoLayoutMode_Tag tag;
+  union {
+    struct {
+      const struct CanvasGPUPipelineLayout *layout;
+    };
+    struct {
+      enum CanvasGPUAutoLayoutMode auto_;
+    };
+  };
+} CanvasGPUPipelineLayoutOrGPUAutoLayoutMode;
+
+typedef struct CanvasProgrammableStage {
+  const struct CanvasGPUShaderModule *module;
+  const char *entry_point;
+  const struct CanvasConstants *constants;
+} CanvasProgrammableStage;
+
+typedef struct CanvasCreateRenderBundleEncoderDescriptor {
+  const char *label;
+  const struct CanvasGPUTextureFormat *color_formats;
+  uintptr_t color_formats_size;
+  const struct CanvasGPUTextureFormat *depth_stencil_format;
+  uint32_t sample_count;
+  bool depth_read_only;
+  bool stencil_read_only;
+} CanvasCreateRenderBundleEncoderDescriptor;
+
+typedef struct CanvasVertexAttribute {
+  enum CanvasVertexFormat format;
+  uint64_t offset;
+  uint32_t shader_location;
+} CanvasVertexAttribute;
+
+typedef struct CanvasVertexBufferLayout {
+  uint64_t array_stride;
+  enum CanvasVertexStepMode step_mode;
+  const struct CanvasVertexAttribute *attributes;
+  uintptr_t attributes_size;
+} CanvasVertexBufferLayout;
+
+typedef struct CanvasVertexState {
+  const struct CanvasGPUShaderModule *module;
+  const char *entry_point;
+  const struct CanvasConstants *constants;
+  const struct CanvasVertexBufferLayout *buffers;
+  uintptr_t buffers_size;
+} CanvasVertexState;
+
+typedef enum CanvasOptionalIndexFormat_Tag {
+  CanvasOptionalIndexFormatNone,
+  CanvasOptionalIndexFormatSome,
+} CanvasOptionalIndexFormat_Tag;
+
+typedef struct CanvasOptionalIndexFormat {
+  CanvasOptionalIndexFormat_Tag tag;
+  union {
+    struct {
+      enum CanvasIndexFormat some;
+    };
+  };
+} CanvasOptionalIndexFormat;
+
+typedef struct CanvasPrimitiveState {
+  enum CanvasPrimitiveTopology topology;
+  struct CanvasOptionalIndexFormat strip_index_format;
+  enum CanvasFrontFace front_face;
+  enum CanvasCullMode cull_mode;
+  bool unclipped_depth;
+} CanvasPrimitiveState;
+
 typedef struct CanvasStencilFaceState {
   enum CanvasCompareFunction compare;
   enum CanvasStencilOperation fail_op;
@@ -1356,6 +1618,34 @@ typedef struct CanvasCreateTextureDescriptor {
   uintptr_t view_formats_size;
 } CanvasCreateTextureDescriptor;
 
+typedef enum CanvasOptionalCompareFunction_Tag {
+  CanvasOptionalCompareFunctionNone,
+  CanvasOptionalCompareFunctionSome,
+} CanvasOptionalCompareFunction_Tag;
+
+typedef struct CanvasOptionalCompareFunction {
+  CanvasOptionalCompareFunction_Tag tag;
+  union {
+    struct {
+      enum CanvasCompareFunction some;
+    };
+  };
+} CanvasOptionalCompareFunction;
+
+typedef struct CanvasCreateSamplerDescriptor {
+  const char *label;
+  enum CanvasAddressMode address_mode_u;
+  enum CanvasAddressMode address_mode_v;
+  enum CanvasAddressMode address_mode_w;
+  enum CanvasFilterMode mag_filter;
+  enum CanvasFilterMode min_filter;
+  enum CanvasFilterMode mipmap_filter;
+  float lod_min_clamp;
+  float lod_max_clamp;
+  struct CanvasOptionalCompareFunction compare;
+  uint16_t max_anisotropy;
+} CanvasCreateSamplerDescriptor;
+
 typedef struct CanvasOrigin2d {
   /**
    *
@@ -4085,9 +4375,9 @@ void canvas_native_matrix_destroy(struct Matrix *value);
 
 void canvas_native_path_destroy(struct Path *value);
 
-struct CanvasWebGPUInstance *canvas_native_webgpu_instance_create(void);
+const struct CanvasWebGPUInstance *canvas_native_webgpu_instance_create(void);
 
-void canvas_native_webgpu_instance_destroy(struct CanvasWebGPUInstance *instance);
+void canvas_native_webgpu_instance_release(const struct CanvasWebGPUInstance *instance);
 
 void canvas_native_webgpu_request_adapter(const struct CanvasWebGPUInstance *instance,
                                           const struct CanvasGPURequestAdapterOptions *options,
@@ -4096,13 +4386,15 @@ void canvas_native_webgpu_request_adapter(const struct CanvasWebGPUInstance *ins
 
 char *canvas_native_webgpu_adapter_info_vendor(const struct CanvasGPUAdapterInfo *info);
 
-char *canvas_native_webgpu_adapter_info_architecture(const struct CanvasGPUAdapterInfo *info);
+char *canvas_native_webgpu_adapter_info_architecture(const struct CanvasGPUAdapterInfo *_info);
 
 char *canvas_native_webgpu_adapter_info_device(const struct CanvasGPUAdapterInfo *info);
 
 char *canvas_native_webgpu_adapter_info_description(const struct CanvasGPUAdapterInfo *info);
 
-void canvas_native_webgpu_adapter_info_destroy(struct CanvasGPUAdapterInfo *info);
+void canvas_native_webgpu_adapter_info_reference(const struct CanvasGPUAdapterInfo *info);
+
+void canvas_native_webgpu_adapter_info_release(const struct CanvasGPUAdapterInfo *info);
 
 struct StringBuffer *canvas_native_webgpu_adapter_get_features(const struct CanvasGPUAdapter *adapter);
 
@@ -4110,25 +4402,27 @@ bool canvas_native_webgpu_adapter_is_fallback_adapter(const struct CanvasGPUAdap
 
 struct CanvasGPUSupportedLimits *canvas_native_webgpu_adapter_get_limits(const struct CanvasGPUAdapter *adapter);
 
-struct CanvasGPUAdapterInfo *canvas_native_webgpu_request_adapter_info(struct CanvasGPUAdapter *adapter);
+const struct CanvasGPUAdapterInfo *canvas_native_webgpu_request_adapter_info(struct CanvasGPUAdapter *adapter);
 
-void canvas_native_webgpu_request_device(struct CanvasGPUAdapter *adapter,
+void canvas_native_webgpu_request_device(const struct CanvasGPUAdapter *adapter,
                                          const char *label,
                                          const char *const *required_features,
                                          uintptr_t required_features_length,
                                          const struct CanvasGPUSupportedLimits *required_limits,
-                                         void (*callback)(char*, struct CanvasGPUDevice*, void*),
+                                         void (*callback)(char*,
+                                                          const struct CanvasGPUDevice*,
+                                                          void*),
                                          void *callback_data);
 
 uint32_t canvas_native_webgpu_buffer_usage(const struct CanvasGPUBuffer *buffer);
 
 uint64_t canvas_native_webgpu_buffer_size(const struct CanvasGPUBuffer *buffer);
 
-char *canvas_native_webgpu_buffer_get_mapped_range(const struct CanvasGPUBuffer *buffer,
-                                                   int64_t offset,
-                                                   int64_t size,
-                                                   uint8_t *dst,
-                                                   uintptr_t dst_size);
+void canvas_native_webgpu_buffer_get_mapped_range(const struct CanvasGPUBuffer *buffer,
+                                                  int64_t offset,
+                                                  int64_t size,
+                                                  uint8_t *dst,
+                                                  uintptr_t dst_size);
 
 void canvas_native_webgpu_buffer_destroy(const struct CanvasGPUBuffer *buffer);
 
@@ -4141,95 +4435,173 @@ void canvas_native_webgpu_buffer_map_async(const struct CanvasGPUBuffer *buffer,
                                            void (*callback)(char*, void*),
                                            void *callback_data);
 
-struct CanvasGPUComputePass *canvas_native_webgpu_command_encoder_begin_compute_pass(struct CanvasGPUCommandEncoder *command_encoder,
-                                                                                     const struct CanvasGPUQuerySet *query_set,
-                                                                                     const char *label,
-                                                                                     int32_t beginning_of_pass_write_index,
-                                                                                     int32_t end_of_pass_write_index);
-
-struct CanvasGPURenderPass *canvas_native_webgpu_command_encoder_begin_render_pass(struct CanvasGPUCommandEncoder *command_encoder,
-                                                                                   const char *label,
-                                                                                   const struct CanvasRenderPassColorAttachment *color_attachments,
-                                                                                   uintptr_t color_attachments_size,
-                                                                                   const struct CanvasRenderPassDepthStencilAttachment *depth_stencil_attachment,
-                                                                                   const struct CanvasGPUQuerySet *occlusion_query_set,
-                                                                                   const struct CanvasGPUQuerySet *query_set,
-                                                                                   int32_t beginning_of_pass_write_index,
-                                                                                   int32_t end_of_pass_write_index);
-
-void canvas_native_webgpu_command_encoder_clear_buffer(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_reference(const struct CanvasGPUCommandEncoder *command_encoder);
+
+void canvas_native_webgpu_command_encoder_release(const struct CanvasGPUCommandEncoder *command_encoder);
+
+const struct CanvasGPUComputePassEncoder *canvas_native_webgpu_command_encoder_begin_compute_pass(const struct CanvasGPUCommandEncoder *command_encoder,
+                                                                                                  const struct CanvasGPUQuerySet *query_set,
+                                                                                                  const char *label,
+                                                                                                  int32_t beginning_of_pass_write_index,
+                                                                                                  int32_t end_of_pass_write_index);
+
+const struct CanvasGPURenderPassEncoder *canvas_native_webgpu_command_encoder_begin_render_pass(const struct CanvasGPUCommandEncoder *command_encoder,
+                                                                                                const char *label,
+                                                                                                const struct CanvasRenderPassColorAttachment *color_attachments,
+                                                                                                uintptr_t color_attachments_size,
+                                                                                                const struct CanvasRenderPassDepthStencilAttachment *depth_stencil_attachment,
+                                                                                                const struct CanvasGPUQuerySet *occlusion_query_set,
+                                                                                                const struct CanvasGPUQuerySet *query_set,
+                                                                                                int32_t beginning_of_pass_write_index,
+                                                                                                int32_t end_of_pass_write_index);
+
+void canvas_native_webgpu_command_encoder_clear_buffer(const struct CanvasGPUCommandEncoder *command_encoder,
                                                        const struct CanvasGPUBuffer *buffer,
                                                        int64_t offset,
                                                        int64_t size);
 
-void canvas_native_webgpu_command_encoder_copy_buffer_to_buffer(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_copy_buffer_to_buffer(const struct CanvasGPUCommandEncoder *command_encoder,
                                                                 const struct CanvasGPUBuffer *src,
                                                                 int64_t src_offset,
                                                                 const struct CanvasGPUBuffer *dst,
                                                                 int64_t dst_offset,
                                                                 uint64_t size);
 
-void canvas_native_webgpu_command_encoder_copy_buffer_to_texture(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_copy_buffer_to_texture(const struct CanvasGPUCommandEncoder *command_encoder,
                                                                  const struct CanvasImageCopyBuffer *src,
                                                                  const struct CanvasImageCopyTexture *dst,
                                                                  const struct CanvasExtent3d *copy_size);
 
-void canvas_native_webgpu_command_encoder_copy_texture_to_buffer(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_copy_texture_to_buffer(const struct CanvasGPUCommandEncoder *command_encoder,
                                                                  const struct CanvasImageCopyTexture *src,
                                                                  const struct CanvasImageCopyBuffer *dst,
                                                                  const struct CanvasExtent3d *copy_size);
 
-void canvas_native_webgpu_command_encoder_copy_texture_to_texture(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_copy_texture_to_texture(const struct CanvasGPUCommandEncoder *command_encoder,
                                                                   const struct CanvasImageCopyTexture *src,
                                                                   const struct CanvasImageCopyTexture *dst,
                                                                   const struct CanvasExtent3d *copy_size);
 
-struct CanvasGPUCommandBuffer *canvas_native_webgpu_command_encoder_finish(struct CanvasGPUCommandEncoder *command_encoder,
-                                                                           const char *label);
+const struct CanvasGPUCommandBuffer *canvas_native_webgpu_command_encoder_finish(const struct CanvasGPUCommandEncoder *command_encoder,
+                                                                                 const char *label);
 
-void canvas_native_webgpu_command_encoder_pop_debug_group(struct CanvasGPUCommandEncoder *command_encoder);
+void canvas_native_webgpu_command_encoder_pop_debug_group(const struct CanvasGPUCommandEncoder *command_encoder);
 
-void canvas_native_webgpu_command_encoder_push_debug_group(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_push_debug_group(const struct CanvasGPUCommandEncoder *command_encoder,
                                                            const char *label);
 
-void canvas_native_webgpu_command_encoder_resolve_query_set(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_resolve_query_set(const struct CanvasGPUCommandEncoder *command_encoder,
                                                             const struct CanvasGPUQuerySet *query_set,
                                                             uint32_t first_query,
                                                             uint32_t query_count,
                                                             struct CanvasGPUBuffer *dst,
                                                             uint64_t dst_offset);
 
-void canvas_native_webgpu_command_encoder_write_timestamp(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_write_timestamp(const struct CanvasGPUCommandEncoder *command_encoder,
                                                           const struct CanvasGPUQuerySet *query_set,
                                                           uint32_t query_index);
 
+void canvas_native_webgpu_compute_pass_reference(const struct CanvasGPUComputePassEncoder *compute_pass);
+
+void canvas_native_webgpu_compute_pass_release(const struct CanvasGPUComputePassEncoder *compute_pass);
+
+void canvas_native_webgpu_compute_pass_dispatch_workgroups(const struct CanvasGPUComputePassEncoder *compute_pass,
+                                                           uint32_t workgroup_count_x,
+                                                           uint32_t workgroup_count_y,
+                                                           uint32_t workgroup_count_z);
+
+void canvas_native_webgpu_compute_pass_dispatch_workgroups_indirect(const struct CanvasGPUComputePassEncoder *compute_pass,
+                                                                    const struct CanvasGPUBuffer *indirect_buffer,
+                                                                    uintptr_t indirect_offset);
+
+void canvas_native_webgpu_compute_pass_end(const struct CanvasGPUComputePassEncoder *compute_pass);
+
+void canvas_native_webgpu_compute_pass_insert_debug_marker(const struct CanvasGPUComputePassEncoder *compute_pass,
+                                                           const char *label);
+
+void canvas_native_webgpu_compute_pass_pop_debug_group(const struct CanvasGPUComputePassEncoder *compute_pass);
+
+void canvas_native_webgpu_compute_pass_push_debug_group(const struct CanvasGPUComputePassEncoder *compute_pass,
+                                                        const char *label);
+
+void canvas_native_webgpu_compute_pass_set_bind_group(const struct CanvasGPUComputePassEncoder *compute_pass,
+                                                      uint32_t index,
+                                                      const struct CanvasGPUBindGroup *bind_group,
+                                                      const uint32_t *dynamic_offsets,
+                                                      uintptr_t dynamic_offsets_size,
+                                                      uintptr_t dynamic_offsets_start,
+                                                      uintptr_t dynamic_offsets_length);
+
+void canvas_native_webgpu_compute_pass_set_pipeline(struct CanvasGPUComputePassEncoder *compute_pass,
+                                                    const struct CanvasGPUComputePipeline *pipeline);
+
 struct StringBuffer *canvas_native_webgpu_device_get_features(const struct CanvasGPUDevice *device);
 
 struct CanvasGPUSupportedLimits *canvas_native_webgpu_device_get_limits(const struct CanvasGPUDevice *device);
 
-struct CanvasGPUQueue *canvas_native_webgpu_device_get_queue(const struct CanvasGPUDevice *device);
+const struct CanvasGPUQueue *canvas_native_webgpu_device_get_queue(const struct CanvasGPUDevice *device);
 
 void canvas_native_webgpu_device_set_lost_callback(const struct CanvasGPUDevice *device,
                                                    void (*callback)(int32_t, char*, void*),
-                                                   void *callback_data);
+                                                   void *userdata);
 
 void canvas_native_webgpu_device_destroy(const struct CanvasGPUDevice *device);
 
-void canvas_native_webgpu_device_destroy_destory(struct CanvasGPUDevice *device);
+void canvas_native_webgpu_device_reference(const struct CanvasGPUDevice *device);
 
-struct CanvasGPUCommandEncoder *canvas_native_webgpu_device_create_command_encoder(const struct CanvasGPUDevice *device,
-                                                                                   const char *label);
+void canvas_native_webgpu_device_release(const struct CanvasGPUDevice *device);
 
-struct CanvasGPUShaderModule *canvas_native_webgpu_device_create_shader_module(const struct CanvasGPUDevice *device,
+const struct CanvasGPUBindGroupLayout *canvas_native_webgpu_device_create_bind_group_layout(const struct CanvasGPUDevice *device,
+                                                                                            const char *label,
+                                                                                            const struct CanvasBindGroupLayoutEntry *entries,
+                                                                                            uintptr_t size);
+
+const struct CanvasGPUBindGroup *canvas_native_webgpu_device_create_bind_group(const struct CanvasGPUDevice *device,
                                                                                const char *label,
-                                                                               const char *source);
+                                                                               const struct CanvasGPUBindGroupLayout *layout,
+                                                                               const struct CanvasBindGroupEntry *entries,
+                                                                               uintptr_t size);
+
+const struct CanvasGPUCommandEncoder *canvas_native_webgpu_device_create_command_encoder(const struct CanvasGPUDevice *device,
+                                                                                         const char *label);
+
+const struct CanvasGPUComputePipeline *canvas_native_webgpu_device_create_compute_pipeline(const struct CanvasGPUDevice *device,
+                                                                                           const char *label,
+                                                                                           struct CanvasGPUPipelineLayoutOrGPUAutoLayoutMode layout,
+                                                                                           const struct CanvasProgrammableStage *compute);
+
+void canvas_native_webgpu_device_create_compute_pipeline_async(const struct CanvasGPUDevice *device,
+                                                               const char *label,
+                                                               struct CanvasGPUPipelineLayoutOrGPUAutoLayoutMode layout,
+                                                               const struct CanvasProgrammableStage *compute,
+                                                               void (*callback)(const struct CanvasGPUComputePipeline*,
+                                                                                enum CanvasGPUErrorType,
+                                                                                char*,
+                                                                                void*),
+                                                               void *callback_data);
+
+const struct CanvasGPUPipelineLayout *canvas_native_webgpu_device_create_pipeline_layout(const struct CanvasGPUDevice *device,
+                                                                                         const char *label,
+                                                                                         const struct CanvasGPUBindGroupLayout *group_layouts,
+                                                                                         uintptr_t size);
+
+const struct CanvasGPUQuerySet *canvas_native_webgpu_device_create_query_set(const struct CanvasGPUDevice *device,
+                                                                             const char *label,
+                                                                             enum CanvasQueryType type_,
+                                                                             uint32_t count);
+
+const struct CanvasGPURenderBundleEncoder *canvas_native_webgpu_device_create_render_bundle_encoder(const struct CanvasGPUDevice *device,
+                                                                                                    const struct CanvasCreateRenderBundleEncoderDescriptor *descriptor);
+
+const struct CanvasGPUShaderModule *canvas_native_webgpu_device_create_shader_module(const struct CanvasGPUDevice *device,
+                                                                                     const char *label,
+                                                                                     const char *source);
 
-struct CanvasGPUBuffer *canvas_native_webgpu_device_create_buffer(const struct CanvasGPUDevice *device,
-                                                                  const char *label,
-                                                                  uint64_t size,
-                                                                  uint32_t usage,
-                                                                  bool mapped_at_creation,
-                                                                  char *error);
+const struct CanvasGPUBuffer *canvas_native_webgpu_device_create_buffer(const struct CanvasGPUDevice *device,
+                                                                        const char *label,
+                                                                        uint64_t size,
+                                                                        uint32_t usage,
+                                                                        bool mapped_at_creation);
 
 struct CanvasConstants *canvas_native_webgpu_constants_create(void);
 
@@ -4239,35 +4611,45 @@ void canvas_native_webgpu_constants_insert(struct CanvasConstants *constants,
 
 void canvas_native_webgpu_constants_destroy(struct CanvasConstants *constants);
 
-struct CanvasGPURenderPipeline *canvas_native_webgpu_device_create_render_pipeline(const struct CanvasGPUDevice *device,
-                                                                                   const struct CanvasCreateRenderPipelineDescriptor *descriptor);
+const struct CanvasGPURenderPipeline *canvas_native_webgpu_device_create_render_pipeline(const struct CanvasGPUDevice *device,
+                                                                                         const struct CanvasCreateRenderPipelineDescriptor *descriptor);
 
-struct CanvasGPUTexture *canvas_native_webgpu_device_create_texture(const struct CanvasGPUDevice *device,
-                                                                    const struct CanvasCreateTextureDescriptor *descriptor,
-                                                                    char *error);
+void canvas_native_webgpu_device_create_render_pipeline_async(const struct CanvasGPUDevice *device,
+                                                              const struct CanvasCreateRenderPipelineDescriptor *descriptor,
+                                                              void (*callback)(const struct CanvasGPURenderPipeline*,
+                                                                               enum CanvasGPUErrorType,
+                                                                               char*,
+                                                                               void*),
+                                                              void *callback_data);
 
-void canvas_native_webgpu_queue_copy_external_image_to_texture(struct CanvasGPUQueue *queue,
+const struct CanvasGPUTexture *canvas_native_webgpu_device_create_texture(const struct CanvasGPUDevice *device,
+                                                                          const struct CanvasCreateTextureDescriptor *descriptor);
+
+const struct CanvasGPUSampler *canvas_native_webgpu_device_create_sampler(const struct CanvasGPUDevice *device,
+                                                                          const struct CanvasCreateSamplerDescriptor *descriptor);
+
+void canvas_native_webgpu_queue_copy_external_image_to_texture(const struct CanvasGPUQueue *queue,
                                                                const struct CanvasImageCopyExternalImage *source,
                                                                const struct CanvasImageCopyTexture *destination,
                                                                const struct CanvasExtent3d *size);
 
-void canvas_native_webgpu_queue_on_submitted_work_done(struct CanvasGPUQueue *queue,
+void canvas_native_webgpu_queue_on_submitted_work_done(const struct CanvasGPUQueue *queue,
                                                        void (*callback)(char*, void*),
                                                        void *callback_data);
 
-void canvas_native_webgpu_queue_submit(struct CanvasGPUQueue *queue,
+void canvas_native_webgpu_queue_submit(const struct CanvasGPUQueue *queue,
                                        const struct CanvasGPUCommandBuffer *const *command_buffers,
                                        uintptr_t command_buffers_size);
 
-void canvas_native_webgpu_queue_write_buffer(struct CanvasGPUQueue *queue,
-                                             struct CanvasGPUBuffer *buffer,
+void canvas_native_webgpu_queue_write_buffer(const struct CanvasGPUQueue *queue,
+                                             const struct CanvasGPUBuffer *buffer,
                                              uint64_t buffer_offset,
                                              const uint8_t *data,
                                              uintptr_t data_size,
                                              uintptr_t data_offset,
                                              intptr_t size);
 
-void canvas_native_webgpu_queue_write_texture(struct CanvasGPUQueue *queue,
+void canvas_native_webgpu_queue_write_texture(const struct CanvasGPUQueue *queue,
                                               const struct CanvasImageCopyTexture *destination,
                                               const struct CanvasImageDataLayout *data_layout,
                                               const struct CanvasExtent3d *size,
@@ -4276,49 +4658,49 @@ void canvas_native_webgpu_queue_write_texture(struct CanvasGPUQueue *queue,
 
 struct CanvasGPUSupportedLimits *canvas_native_webgpu_create_limits(void);
 
-void canvas_native_webgpu_limits_destroy(struct CanvasGPUSupportedLimits *limits);
+void canvas_native_webgpu_limits_release(struct CanvasGPUSupportedLimits *limits);
 
-void canvas_native_webgpu_render_pass_begin_occlusion_query(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_begin_occlusion_query(const struct CanvasGPURenderPassEncoder *render_pass,
                                                             uint32_t query_index);
 
-void canvas_native_webgpu_render_pass_encoder_draw(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_encoder_draw(const struct CanvasGPURenderPassEncoder *render_pass,
                                                    uint32_t vertex_count,
                                                    uint32_t instance_count,
                                                    uint32_t first_vertex,
                                                    uint32_t first_instance);
 
-void canvas_native_webgpu_render_pass_draw_indexed(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_draw_indexed(const struct CanvasGPURenderPassEncoder *render_pass,
                                                    uint32_t index_count,
                                                    uint32_t instance_count,
                                                    uint32_t first_index,
                                                    int32_t base_vertex,
                                                    uint32_t first_instance);
 
-void canvas_native_webgpu_render_pass_draw_indexed_indirect(struct CanvasGPURenderPass *render_pass,
-                                                            struct CanvasGPUBuffer *indirect_buffer,
+void canvas_native_webgpu_render_pass_draw_indexed_indirect(const struct CanvasGPURenderPassEncoder *render_pass,
+                                                            const struct CanvasGPUBuffer *indirect_buffer,
                                                             uint64_t indirect_offset);
 
-void canvas_native_webgpu_render_pass_draw_indirect(struct CanvasGPURenderPass *render_pass,
-                                                    struct CanvasGPUBuffer *indirect_buffer,
+void canvas_native_webgpu_render_pass_draw_indirect(const struct CanvasGPURenderPassEncoder *render_pass,
+                                                    const struct CanvasGPUBuffer *indirect_buffer,
                                                     uint64_t indirect_offset);
 
-void canvas_native_webgpu_render_pass_end(struct CanvasGPURenderPass *render_pass);
+void canvas_native_webgpu_render_pass_end(const struct CanvasGPURenderPassEncoder *render_pass);
 
-void canvas_native_webgpu_render_pass_end_occlusion_query(struct CanvasGPURenderPass *render_pass);
+void canvas_native_webgpu_render_pass_end_occlusion_query(const struct CanvasGPURenderPassEncoder *render_pass);
 
-void canvas_native_webgpu_render_pass_execute_bundles(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_execute_bundles(const struct CanvasGPURenderPassEncoder *render_pass,
                                                       const struct CanvasGPURenderBundle *bundles,
                                                       uintptr_t bundles_size);
 
-void canvas_native_webgpu_render_pass_insert_debug_marker(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_insert_debug_marker(const struct CanvasGPURenderPassEncoder *render_pass,
                                                           const char *label);
 
-void canvas_native_webgpu_render_pass_pop_debug_group(struct CanvasGPURenderPass *render_pass);
+void canvas_native_webgpu_render_pass_pop_debug_group(const struct CanvasGPURenderPassEncoder *render_pass);
 
-void canvas_native_webgpu_render_pass_push_debug_group(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_push_debug_group(const struct CanvasGPURenderPassEncoder *render_pass,
                                                        const char *label);
 
-void canvas_native_webgpu_render_pass_set_bind_group(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_bind_group(const struct CanvasGPURenderPassEncoder *render_pass,
                                                      uint32_t index,
                                                      const struct CanvasGPUBindGroup *bind_group,
                                                      const uint32_t *dynamic_offsets,
@@ -4326,34 +4708,34 @@ void canvas_native_webgpu_render_pass_set_bind_group(struct CanvasGPURenderPass
                                                      uintptr_t dynamic_offsets_start,
                                                      uintptr_t dynamic_offsets_length);
 
-void canvas_native_webgpu_render_pass_set_blend_constant(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_blend_constant(const struct CanvasGPURenderPassEncoder *render_pass,
                                                          const struct CanvasColor *color);
 
-void canvas_native_webgpu_render_pass_set_index_buffer(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_index_buffer(const struct CanvasGPURenderPassEncoder *render_pass,
                                                        const struct CanvasGPUBuffer *buffer,
                                                        enum CanvasIndexFormat index_format,
                                                        int64_t offset,
                                                        int64_t size);
 
-void canvas_native_webgpu_render_pass_set_pipeline(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_pipeline(const struct CanvasGPURenderPassEncoder *render_pass,
                                                    const struct CanvasGPURenderPipeline *pipeline);
 
-void canvas_native_webgpu_render_pass_set_scissor_rect(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_scissor_rect(const struct CanvasGPURenderPassEncoder *render_pass,
                                                        uint32_t x,
                                                        uint32_t y,
                                                        uint32_t width,
                                                        uint32_t height);
 
-void canvas_native_webgpu_render_pass_set_stencil_reference(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_stencil_reference(const struct CanvasGPURenderPassEncoder *render_pass,
                                                             uint32_t reference);
 
-void canvas_native_webgpu_render_pass_set_vertex_buffer(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_vertex_buffer(const struct CanvasGPURenderPassEncoder *render_pass,
                                                         uint32_t slot,
-                                                        struct CanvasGPUBuffer *buffer,
+                                                        const struct CanvasGPUBuffer *buffer,
                                                         int64_t offset,
                                                         int64_t size);
 
-void canvas_native_webgpu_render_pass_set_viewport(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_viewport(const struct CanvasGPURenderPassEncoder *render_pass,
                                                    float x,
                                                    float y,
                                                    float width,
@@ -4361,73 +4743,105 @@ void canvas_native_webgpu_render_pass_set_viewport(struct CanvasGPURenderPass *r
                                                    float depth_min,
                                                    float depth_max);
 
+void canvas_native_webgpu_render_pass_reference(const struct CanvasGPURenderPassEncoder *render_pass);
+
+void canvas_native_webgpu_render_pass_release(const struct CanvasGPURenderPassEncoder *render_pass);
+
 #if defined(TARGET_OS_ANDROID)
-struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create(struct CanvasWebGPUInstance *instance,
-                                                                   void *window,
-                                                                   uint32_t width,
-                                                                   uint32_t height);
+const struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create(struct CanvasWebGPUInstance *instance,
+                                                                         void *window,
+                                                                         uint32_t width,
+                                                                         uint32_t height);
 #endif
 
 #if (defined(TARGET_OS_IOS) || defined(TARGET_OS_MACOS))
-struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create(struct CanvasWebGPUInstance *instance,
-                                                                   void *view,
-                                                                   uint32_t width,
-                                                                   uint32_t height);
+const struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create(const struct CanvasWebGPUInstance *instance,
+                                                                         void *view,
+                                                                         uint32_t width,
+                                                                         uint32_t height);
 #endif
 
 #if defined(TARGET_OS_IOS)
-struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create_uiview(struct CanvasWebGPUInstance *instance,
-                                                                          void *view,
-                                                                          uint32_t width,
-                                                                          uint32_t height);
+const struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create_uiview(const struct CanvasWebGPUInstance *instance,
+                                                                                void *view,
+                                                                                uint32_t width,
+                                                                                uint32_t height);
 #endif
 
 #if defined(TARGET_OS_MACOS)
-struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create_nsview(struct CanvasWebGPUInstance *instance,
-                                                                          void *view,
-                                                                          uint32_t width,
-                                                                          uint32_t height);
+const struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create_nsview(const struct CanvasWebGPUInstance *instance,
+                                                                                void *view,
+                                                                                uint32_t width,
+                                                                                uint32_t height);
 #endif
 
-void canvas_native_webgpu_context_configure(struct CanvasGPUCanvasContext *context,
-                                            struct CanvasGPUDevice *device,
+void canvas_native_webgpu_context_configure(const struct CanvasGPUCanvasContext *context,
+                                            const struct CanvasGPUDevice *device,
                                             const struct CanvasGPUSurfaceConfiguration *config);
 
-void canvas_native_webgpu_context_unconfigure(struct CanvasGPUCanvasContext *context,
+void canvas_native_webgpu_context_unconfigure(const struct CanvasGPUCanvasContext *context,
                                               struct CanvasGPUDevice *device,
                                               const struct CanvasGPUSurfaceConfiguration *config);
 
-struct CanvasGPUTexture *canvas_native_webgpu_context_get_current_texture(struct CanvasGPUCanvasContext *context);
+const struct CanvasGPUTexture *canvas_native_webgpu_context_get_current_texture(const struct CanvasGPUCanvasContext *context);
+
+void canvas_native_webgpu_context_present_surface(const struct CanvasGPUCanvasContext *context);
+
+void canvas_native_webgpu_context_get_capabilities(const struct CanvasGPUCanvasContext *context,
+                                                   const struct CanvasGPUAdapter *adapter);
 
 char *canvas_native_webgpu_enum_gpu_texture_to_string(struct CanvasGPUTextureFormat value);
 
 struct CanvasOptionalGPUTextureFormat canvas_native_webgpu_string_to_gpu_texture_enum(const char *format);
 
-struct CanvasGPUTextureView *canvas_native_webgpu_texture_create_texture_view(struct CanvasGPUTexture *texture,
-                                                                              const struct CanvasCreateTextureViewDescriptor *descriptor);
+void canvas_native_webgpu_texture_reference(const struct CanvasGPUTexture *texture);
+
+void canvas_native_webgpu_texture_release(const struct CanvasGPUTexture *texture);
+
+const struct CanvasGPUTextureView *canvas_native_webgpu_texture_create_texture_view(const struct CanvasGPUTexture *texture,
+                                                                                    const struct CanvasCreateTextureViewDescriptor *descriptor);
+
+uint32_t canvas_native_webgpu_texture_get_depth_or_array_layers(const struct CanvasGPUTexture *texture);
+
+uint32_t canvas_native_webgpu_texture_get_width(const struct CanvasGPUTexture *texture);
+
+uint32_t canvas_native_webgpu_texture_get_height(const struct CanvasGPUTexture *texture);
+
+enum CanvasTextureDimension canvas_native_webgpu_texture_get_dimension(const struct CanvasGPUTexture *texture);
+
+struct CanvasGPUTextureFormat canvas_native_webgpu_texture_get_format(const struct CanvasGPUTexture *texture);
+
+uint32_t canvas_native_webgpu_texture_get_usage(const struct CanvasGPUTexture *texture);
+
+char *canvas_native_webgpu_texture_get_label(const struct CanvasGPUTexture *_texture);
+
+uint32_t canvas_native_webgpu_texture_get_mip_level_count(const struct CanvasGPUTexture *texture);
+
+uint32_t canvas_native_webgpu_texture_get_sample_count(const struct CanvasGPUTexture *texture);
 
-uint32_t canvas_native_webgpu_texture_get_depth_or_array_layers(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_texture_destroy(const struct CanvasGPUTexture *texture);
 
-uint32_t canvas_native_webgpu_texture_get_width(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_texture_view_reference(const struct CanvasGPUTextureView *texture_view);
 
-uint32_t canvas_native_webgpu_texture_get_height(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_texture_view_release(const struct CanvasGPUTextureView *texture_view);
 
-enum CanvasTextureDimension canvas_native_webgpu_texture_get_dimension(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_bind_group_reference(const struct CanvasGPUBindGroup *bind_group);
 
-struct CanvasGPUTextureFormat canvas_native_webgpu_texture_get_format(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_bind_group_release(const struct CanvasGPUBindGroup *bind_group);
 
-uint32_t canvas_native_webgpu_texture_get_usage(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_bind_group_layout_reference(const struct CanvasGPUBindGroupLayout *bind_group_layout);
 
-char *canvas_native_webgpu_texture_get_label(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_bind_group_layout_release(const struct CanvasGPUBindGroupLayout *bind_group_layout);
 
-uint32_t canvas_native_webgpu_texture_get_mip_level_count(struct CanvasGPUTexture *texture);
+const struct CanvasGPUBindGroupLayout *canvas_native_webgpu_render_pipeline_get_bind_group_layout(const struct CanvasGPURenderPipeline *pipeline,
+                                                                                                  uint32_t index);
 
-uint32_t canvas_native_webgpu_texture_get_sample_count(struct CanvasGPUTexture *texture);
+enum CanvasGPUErrorType canvas_native_webgpu_error_get_type(const struct CanvasGPUError *error);
 
-char *canvas_native_webgpu_texture_destroy(struct CanvasGPUTexture *texture);
+char *canvas_native_webgpu_error_get_message(const struct CanvasGPUError *error);
 
-struct CanvasGPUBindGroupLayout *canvas_native_webgpu_render_pipeline_get_bind_group_layout(const struct CanvasGPURenderPipeline *pipeline,
-                                                                                            uint32_t index);
+const struct CanvasGPUBindGroupLayout *canvas_native_webgpu_compute_pipeline_get_bind_group_layout(const struct CanvasGPUComputePipeline *pipeline,
+                                                                                                   uint32_t index);
 
 const uint8_t *canvas_native_u8_buffer_get_bytes(const struct U8Buffer *buffer);
 
diff --git a/packages/canvas/src-native/canvas-ios/CanvasNative.xcodeproj/project.xcworkspace/xcuserdata/triniwiz.xcuserdatad/UserInterfaceState.xcuserstate b/packages/canvas/src-native/canvas-ios/CanvasNative.xcodeproj/project.xcworkspace/xcuserdata/triniwiz.xcuserdatad/UserInterfaceState.xcuserstate
index bbae979fa..f50f87eab 100644
Binary files a/packages/canvas/src-native/canvas-ios/CanvasNative.xcodeproj/project.xcworkspace/xcuserdata/triniwiz.xcuserdatad/UserInterfaceState.xcuserstate and b/packages/canvas/src-native/canvas-ios/CanvasNative.xcodeproj/project.xcworkspace/xcuserdata/triniwiz.xcuserdatad/UserInterfaceState.xcuserstate differ
diff --git a/packages/canvas/src-native/canvas-ios/CanvasNative/include/canvas_native.h b/packages/canvas/src-native/canvas-ios/CanvasNative/include/canvas_native.h
index b299e05f8..bdf2fa39e 100644
--- a/packages/canvas/src-native/canvas-ios/CanvasNative/include/canvas_native.h
+++ b/packages/canvas/src-native/canvas-ios/CanvasNative/include/canvas_native.h
@@ -8,6 +8,38 @@
 #include <stdint.h>
 #include <stdlib.h>
 
+typedef enum CanvasAddressMode {
+  /**
+   * Clamp the value to the edge of the texture
+   *
+   * -0.25 -> 0.0
+   * 1.25  -> 1.0
+   */
+  CanvasAddressModeClampToEdge = 0,
+  /**
+   * Repeat the texture in a tiling fashion
+   *
+   * -0.25 -> 0.75
+   * 1.25 -> 0.25
+   */
+  CanvasAddressModeRepeat = 1,
+  /**
+   * Repeat the texture, mirroring it every repeat
+   *
+   * -0.25 -> 0.25
+   * 1.25 -> 0.75
+   */
+  CanvasAddressModeMirrorRepeat = 2,
+  /**
+   * Clamp the value to the border of the texture
+   * Requires feature [`Features::ADDRESS_MODE_CLAMP_TO_BORDER`]
+   *
+   * -0.25 -> border
+   * 1.25 -> border
+   */
+  CanvasAddressModeClampToBorder = 3,
+} CanvasAddressMode;
+
 /**
  * ASTC block dimensions
  */
@@ -188,6 +220,12 @@ typedef enum CanvasBlendOperation {
   CanvasBlendOperationMax = 4,
 } CanvasBlendOperation;
 
+typedef enum CanvasBufferBindingType {
+  CanvasBufferBindingTypeUniform,
+  CanvasBufferBindingTypeStorage,
+  CanvasBufferBindingTypeReadOnlyStorage,
+} CanvasBufferBindingType;
+
 typedef enum CanvasCompareFunction {
   CanvasCompareFunctionNever = 1,
   CanvasCompareFunctionLess = 2,
@@ -205,6 +243,16 @@ typedef enum CanvasCullMode {
   CanvasCullModeBack,
 } CanvasCullMode;
 
+typedef enum CanvasFilterMode {
+  CanvasFilterModeNearest = 0,
+  /**
+   * Linear Interpolation
+   *
+   * This makes textures smooth but blurry when used as a mag filter.
+   */
+  CanvasFilterModeLinear = 1,
+} CanvasFilterMode;
+
 typedef enum CanvasFrontFace {
   CanvasFrontFaceCcw = 0,
   CanvasFrontFaceCw = 1,
@@ -214,6 +262,14 @@ typedef enum CanvasGPUAutoLayoutMode {
   CanvasGPUAutoLayoutModeAuto,
 } CanvasGPUAutoLayoutMode;
 
+typedef enum CanvasGPUErrorType {
+  CanvasGPUErrorTypeNone,
+  CanvasGPUErrorTypeLost,
+  CanvasGPUErrorTypeOutOfMemory,
+  CanvasGPUErrorTypeValidation,
+  CanvasGPUErrorTypeInternal,
+} CanvasGPUErrorType;
+
 typedef enum CanvasGPUPowerPreference {
   CanvasGPUPowerPreferenceNone,
   CanvasGPUPowerPreferenceLowPower,
@@ -271,6 +327,28 @@ typedef enum CanvasPrimitiveTopology {
   CanvasPrimitiveTopologyTriangleStrip = 4,
 } CanvasPrimitiveTopology;
 
+typedef enum CanvasQueryType {
+  CanvasQueryTypeOcclusion,
+  CanvasQueryTypeTimestamp,
+} CanvasQueryType;
+
+typedef enum CanvasSamplerBindingType {
+  /**
+   * The sampling result is produced based on more than a single color sample from a texture,
+   * e.g. when bilinear interpolation is enabled.
+   */
+  CanvasSamplerBindingTypeFiltering,
+  /**
+   * The sampling result is produced based on a single color sample from a texture.
+   */
+  CanvasSamplerBindingTypeNonFiltering,
+  /**
+   * Use as a comparison sampler instead of a normal sampler.
+   * For more info take a look at the analogous functionality in OpenGL: <https://www.khronos.org/opengl/wiki/Sampler_Object#Comparison_mode>.
+   */
+  CanvasSamplerBindingTypeComparison,
+} CanvasSamplerBindingType;
+
 typedef enum CanvasStencilOperation {
   CanvasStencilOperationKeep = 0,
   CanvasStencilOperationZero = 1,
@@ -282,6 +360,64 @@ typedef enum CanvasStencilOperation {
   CanvasStencilOperationDecrementWrap = 7,
 } CanvasStencilOperation;
 
+typedef enum CanvasStorageTextureAccess {
+  /**
+   * The texture can only be written in the shader and it:
+   * - may or may not be annotated with `write` (WGSL).
+   * - must be annotated with `writeonly` (GLSL).
+   *
+   * Example WGSL syntax:
+   * ```rust,ignore
+   * @group(0) @binding(0)
+   * var my_storage_image: texture_storage_2d<f32, write>;
+   * ```
+   *
+   * Example GLSL syntax:
+   * ```cpp,ignore
+   * layout(set=0, binding=0, r32f) writeonly uniform image2D myStorageImage;
+   * ```
+   */
+  CanvasStorageTextureAccessWriteOnly,
+  /**
+   * The texture can only be read in the shader and it must be annotated with `read` (WGSL) or
+   * `readonly` (GLSL).
+   *
+   * [`Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES`] must be enabled to use this access
+   * mode. This is a native-only extension.
+   *
+   * Example WGSL syntax:
+   * ```rust,ignore
+   * @group(0) @binding(0)
+   * var my_storage_image: texture_storage_2d<f32, read>;
+   * ```
+   *
+   * Example GLSL syntax:
+   * ```cpp,ignore
+   * layout(set=0, binding=0, r32f) readonly uniform image2D myStorageImage;
+   * ```
+   */
+  CanvasStorageTextureAccessReadOnly,
+  /**
+   * The texture can be both read and written in the shader and must be annotated with
+   * `read_write` in WGSL.
+   *
+   * [`Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES`] must be enabled to use this access
+   * mode.  This is a nonstandard, native-only extension.
+   *
+   * Example WGSL syntax:
+   * ```rust,ignore
+   * @group(0) @binding(0)
+   * var my_storage_image: texture_storage_2d<f32, read_write>;
+   * ```
+   *
+   * Example GLSL syntax:
+   * ```cpp,ignore
+   * layout(set=0, binding=0, r32f) uniform image2D myStorageImage;
+   * ```
+   */
+  CanvasStorageTextureAccessReadWrite,
+} CanvasStorageTextureAccess;
+
 typedef enum CanvasStoreOp {
   CanvasStoreOpDiscard = 0,
   CanvasStoreOpStore = 1,
@@ -320,6 +456,23 @@ typedef enum CanvasTextureDimension {
   CanvasTextureDimensionD3,
 } CanvasTextureDimension;
 
+typedef enum CanvasTextureSampleType {
+  CanvasTextureSampleTypeFloat,
+  CanvasTextureSampleTypeUnfilterableFloat,
+  CanvasTextureSampleTypeDepth,
+  CanvasTextureSampleTypeSint,
+  CanvasTextureSampleTypeUint,
+} CanvasTextureSampleType;
+
+typedef enum CanvasTextureViewDimension {
+  CanvasTextureViewDimensionD1,
+  CanvasTextureViewDimensionD2,
+  CanvasTextureViewDimensionD2Array,
+  CanvasTextureViewDimensionCube,
+  CanvasTextureViewDimensionCubeArray,
+  CanvasTextureViewDimensionD3,
+} CanvasTextureViewDimension;
+
 typedef enum CanvasVertexFormat {
   CanvasVertexFormatUint8x2 = 0,
   CanvasVertexFormatUint8x4 = 1,
@@ -478,10 +631,14 @@ typedef struct CanvasGPUCommandBuffer CanvasGPUCommandBuffer;
 
 typedef struct CanvasGPUCommandEncoder CanvasGPUCommandEncoder;
 
-typedef struct CanvasGPUComputePass CanvasGPUComputePass;
+typedef struct CanvasGPUComputePassEncoder CanvasGPUComputePassEncoder;
+
+typedef struct CanvasGPUComputePipeline CanvasGPUComputePipeline;
 
 typedef struct CanvasGPUDevice CanvasGPUDevice;
 
+typedef struct CanvasGPUError CanvasGPUError;
+
 typedef struct CanvasGPUPipelineLayout CanvasGPUPipelineLayout;
 
 typedef struct CanvasGPUQuerySet CanvasGPUQuerySet;
@@ -490,10 +647,14 @@ typedef struct CanvasGPUQueue CanvasGPUQueue;
 
 typedef struct CanvasGPURenderBundle CanvasGPURenderBundle;
 
-typedef struct CanvasGPURenderPass CanvasGPURenderPass;
+typedef struct CanvasGPURenderBundleEncoder CanvasGPURenderBundleEncoder;
+
+typedef struct CanvasGPURenderPassEncoder CanvasGPURenderPassEncoder;
 
 typedef struct CanvasGPURenderPipeline CanvasGPURenderPipeline;
 
+typedef struct CanvasGPUSampler CanvasGPUSampler;
+
 typedef struct CanvasGPUShaderModule CanvasGPUShaderModule;
 
 typedef struct CanvasGPUTexture CanvasGPUTexture;
@@ -726,65 +887,21 @@ typedef struct CanvasExtent3d {
   uint32_t depth_or_array_layers;
 } CanvasExtent3d;
 
-typedef enum CanvasGPUPipelineLayoutOrGPUAutoLayoutMode_Tag {
-  CanvasGPUPipelineLayoutOrGPUAutoLayoutModeLayout,
-  CanvasGPUPipelineLayoutOrGPUAutoLayoutModeAuto,
-} CanvasGPUPipelineLayoutOrGPUAutoLayoutMode_Tag;
+typedef struct CanvasBufferBindingLayout {
+  enum CanvasBufferBindingType type_;
+  bool has_dynamic_offset;
+  int64_t min_binding_size;
+} CanvasBufferBindingLayout;
 
-typedef struct CanvasGPUPipelineLayoutOrGPUAutoLayoutMode {
-  CanvasGPUPipelineLayoutOrGPUAutoLayoutMode_Tag tag;
-  union {
-    struct {
-      const struct CanvasGPUPipelineLayout *layout;
-    };
-    struct {
-      enum CanvasGPUAutoLayoutMode auto_;
-    };
-  };
-} CanvasGPUPipelineLayoutOrGPUAutoLayoutMode;
-
-typedef struct CanvasVertexAttribute {
-  enum CanvasVertexFormat format;
-  uint64_t offset;
-  uint32_t shader_location;
-} CanvasVertexAttribute;
-
-typedef struct CanvasVertexBufferLayout {
-  uint64_t array_stride;
-  enum CanvasVertexStepMode step_mode;
-  const struct CanvasVertexAttribute *attributes;
-  uintptr_t attributes_size;
-} CanvasVertexBufferLayout;
+typedef struct CanvasSamplerBindingLayout {
+  enum CanvasSamplerBindingType type_;
+} CanvasSamplerBindingLayout;
 
-typedef struct CanvasVertexState {
-  const struct CanvasGPUShaderModule *module;
-  const char *entry_point;
-  const struct CanvasConstants *constants;
-  const struct CanvasVertexBufferLayout *buffers;
-  uintptr_t buffers_size;
-} CanvasVertexState;
-
-typedef enum CanvasOptionalIndexFormat_Tag {
-  CanvasOptionalIndexFormatNone,
-  CanvasOptionalIndexFormatSome,
-} CanvasOptionalIndexFormat_Tag;
-
-typedef struct CanvasOptionalIndexFormat {
-  CanvasOptionalIndexFormat_Tag tag;
-  union {
-    struct {
-      enum CanvasIndexFormat some;
-    };
-  };
-} CanvasOptionalIndexFormat;
-
-typedef struct CanvasPrimitiveState {
-  enum CanvasPrimitiveTopology topology;
-  struct CanvasOptionalIndexFormat strip_index_format;
-  enum CanvasFrontFace front_face;
-  enum CanvasCullMode cull_mode;
-  bool unclipped_depth;
-} CanvasPrimitiveState;
+typedef struct CanvasTextureBindingLayout {
+  enum CanvasTextureSampleType sample_type;
+  enum CanvasTextureViewDimension view_dimension;
+  bool multisampled;
+} CanvasTextureBindingLayout;
 
 typedef enum CanvasGPUTextureFormat_Tag {
   /**
@@ -1237,6 +1354,151 @@ typedef struct CanvasGPUTextureFormat {
   };
 } CanvasGPUTextureFormat;
 
+typedef struct CanvasStorageTextureBindingLayout {
+  enum CanvasStorageTextureAccess access;
+  struct CanvasGPUTextureFormat format;
+  enum CanvasTextureViewDimension view_dimension;
+} CanvasStorageTextureBindingLayout;
+
+typedef enum CanvasBindingType_Tag {
+  CanvasBindingTypeBuffer,
+  CanvasBindingTypeSampler,
+  CanvasBindingTypeTexture,
+  CanvasBindingTypeStorageTexture,
+} CanvasBindingType_Tag;
+
+typedef struct CanvasBindingType {
+  CanvasBindingType_Tag tag;
+  union {
+    struct {
+      struct CanvasBufferBindingLayout buffer;
+    };
+    struct {
+      struct CanvasSamplerBindingLayout sampler;
+    };
+    struct {
+      struct CanvasTextureBindingLayout texture;
+    };
+    struct {
+      struct CanvasStorageTextureBindingLayout storage_texture;
+    };
+  };
+} CanvasBindingType;
+
+typedef struct CanvasBindGroupLayoutEntry {
+  uint32_t binding;
+  uint32_t visibility;
+  struct CanvasBindingType binding_type;
+} CanvasBindGroupLayoutEntry;
+
+typedef struct CanvasBufferBinding {
+  const struct CanvasGPUBuffer *buffer;
+  int64_t offset;
+  int64_t size;
+} CanvasBufferBinding;
+
+typedef enum CanvasBindGroupEntryResource_Tag {
+  CanvasBindGroupEntryResourceBuffer,
+  CanvasBindGroupEntryResourceSampler,
+  CanvasBindGroupEntryResourceTextureView,
+} CanvasBindGroupEntryResource_Tag;
+
+typedef struct CanvasBindGroupEntryResource {
+  CanvasBindGroupEntryResource_Tag tag;
+  union {
+    struct {
+      struct CanvasBufferBinding buffer;
+    };
+    struct {
+      const struct CanvasGPUSampler *sampler;
+    };
+    struct {
+      const struct CanvasGPUTextureView *texture_view;
+    };
+  };
+} CanvasBindGroupEntryResource;
+
+typedef struct CanvasBindGroupEntry {
+  uint32_t binding;
+  struct CanvasBindGroupEntryResource resource;
+} CanvasBindGroupEntry;
+
+typedef enum CanvasGPUPipelineLayoutOrGPUAutoLayoutMode_Tag {
+  CanvasGPUPipelineLayoutOrGPUAutoLayoutModeLayout,
+  CanvasGPUPipelineLayoutOrGPUAutoLayoutModeAuto,
+} CanvasGPUPipelineLayoutOrGPUAutoLayoutMode_Tag;
+
+typedef struct CanvasGPUPipelineLayoutOrGPUAutoLayoutMode {
+  CanvasGPUPipelineLayoutOrGPUAutoLayoutMode_Tag tag;
+  union {
+    struct {
+      const struct CanvasGPUPipelineLayout *layout;
+    };
+    struct {
+      enum CanvasGPUAutoLayoutMode auto_;
+    };
+  };
+} CanvasGPUPipelineLayoutOrGPUAutoLayoutMode;
+
+typedef struct CanvasProgrammableStage {
+  const struct CanvasGPUShaderModule *module;
+  const char *entry_point;
+  const struct CanvasConstants *constants;
+} CanvasProgrammableStage;
+
+typedef struct CanvasCreateRenderBundleEncoderDescriptor {
+  const char *label;
+  const struct CanvasGPUTextureFormat *color_formats;
+  uintptr_t color_formats_size;
+  const struct CanvasGPUTextureFormat *depth_stencil_format;
+  uint32_t sample_count;
+  bool depth_read_only;
+  bool stencil_read_only;
+} CanvasCreateRenderBundleEncoderDescriptor;
+
+typedef struct CanvasVertexAttribute {
+  enum CanvasVertexFormat format;
+  uint64_t offset;
+  uint32_t shader_location;
+} CanvasVertexAttribute;
+
+typedef struct CanvasVertexBufferLayout {
+  uint64_t array_stride;
+  enum CanvasVertexStepMode step_mode;
+  const struct CanvasVertexAttribute *attributes;
+  uintptr_t attributes_size;
+} CanvasVertexBufferLayout;
+
+typedef struct CanvasVertexState {
+  const struct CanvasGPUShaderModule *module;
+  const char *entry_point;
+  const struct CanvasConstants *constants;
+  const struct CanvasVertexBufferLayout *buffers;
+  uintptr_t buffers_size;
+} CanvasVertexState;
+
+typedef enum CanvasOptionalIndexFormat_Tag {
+  CanvasOptionalIndexFormatNone,
+  CanvasOptionalIndexFormatSome,
+} CanvasOptionalIndexFormat_Tag;
+
+typedef struct CanvasOptionalIndexFormat {
+  CanvasOptionalIndexFormat_Tag tag;
+  union {
+    struct {
+      enum CanvasIndexFormat some;
+    };
+  };
+} CanvasOptionalIndexFormat;
+
+typedef struct CanvasPrimitiveState {
+  enum CanvasPrimitiveTopology topology;
+  struct CanvasOptionalIndexFormat strip_index_format;
+  enum CanvasFrontFace front_face;
+  enum CanvasCullMode cull_mode;
+  bool unclipped_depth;
+} CanvasPrimitiveState;
+
 typedef struct CanvasStencilFaceState {
   enum CanvasCompareFunction compare;
   enum CanvasStencilOperation fail_op;
@@ -1356,6 +1618,34 @@ typedef struct CanvasCreateTextureDescriptor {
   uintptr_t view_formats_size;
 } CanvasCreateTextureDescriptor;
 
+typedef enum CanvasOptionalCompareFunction_Tag {
+  CanvasOptionalCompareFunctionNone,
+  CanvasOptionalCompareFunctionSome,
+} CanvasOptionalCompareFunction_Tag;
+
+typedef struct CanvasOptionalCompareFunction {
+  CanvasOptionalCompareFunction_Tag tag;
+  union {
+    struct {
+      enum CanvasCompareFunction some;
+    };
+  };
+} CanvasOptionalCompareFunction;
+
+typedef struct CanvasCreateSamplerDescriptor {
+  const char *label;
+  enum CanvasAddressMode address_mode_u;
+  enum CanvasAddressMode address_mode_v;
+  enum CanvasAddressMode address_mode_w;
+  enum CanvasFilterMode mag_filter;
+  enum CanvasFilterMode min_filter;
+  enum CanvasFilterMode mipmap_filter;
+  float lod_min_clamp;
+  float lod_max_clamp;
+  struct CanvasOptionalCompareFunction compare;
+  uint16_t max_anisotropy;
+} CanvasCreateSamplerDescriptor;
+
 typedef struct CanvasOrigin2d {
   /**
    *
@@ -4085,9 +4375,9 @@ void canvas_native_matrix_destroy(struct Matrix *value);
 
 void canvas_native_path_destroy(struct Path *value);
 
-struct CanvasWebGPUInstance *canvas_native_webgpu_instance_create(void);
+const struct CanvasWebGPUInstance *canvas_native_webgpu_instance_create(void);
 
-void canvas_native_webgpu_instance_destroy(struct CanvasWebGPUInstance *instance);
+void canvas_native_webgpu_instance_release(const struct CanvasWebGPUInstance *instance);
 
 void canvas_native_webgpu_request_adapter(const struct CanvasWebGPUInstance *instance,
                                           const struct CanvasGPURequestAdapterOptions *options,
@@ -4096,13 +4386,15 @@ void canvas_native_webgpu_request_adapter(const struct CanvasWebGPUInstance *ins
 
 char *canvas_native_webgpu_adapter_info_vendor(const struct CanvasGPUAdapterInfo *info);
 
-char *canvas_native_webgpu_adapter_info_architecture(const struct CanvasGPUAdapterInfo *info);
+char *canvas_native_webgpu_adapter_info_architecture(const struct CanvasGPUAdapterInfo *_info);
 
 char *canvas_native_webgpu_adapter_info_device(const struct CanvasGPUAdapterInfo *info);
 
 char *canvas_native_webgpu_adapter_info_description(const struct CanvasGPUAdapterInfo *info);
 
-void canvas_native_webgpu_adapter_info_destroy(struct CanvasGPUAdapterInfo *info);
+void canvas_native_webgpu_adapter_info_reference(const struct CanvasGPUAdapterInfo *info);
+
+void canvas_native_webgpu_adapter_info_release(const struct CanvasGPUAdapterInfo *info);
 
 struct StringBuffer *canvas_native_webgpu_adapter_get_features(const struct CanvasGPUAdapter *adapter);
 
@@ -4110,25 +4402,27 @@ bool canvas_native_webgpu_adapter_is_fallback_adapter(const struct CanvasGPUAdap
 
 struct CanvasGPUSupportedLimits *canvas_native_webgpu_adapter_get_limits(const struct CanvasGPUAdapter *adapter);
 
-struct CanvasGPUAdapterInfo *canvas_native_webgpu_request_adapter_info(struct CanvasGPUAdapter *adapter);
+const struct CanvasGPUAdapterInfo *canvas_native_webgpu_request_adapter_info(struct CanvasGPUAdapter *adapter);
 
-void canvas_native_webgpu_request_device(struct CanvasGPUAdapter *adapter,
+void canvas_native_webgpu_request_device(const struct CanvasGPUAdapter *adapter,
                                          const char *label,
                                          const char *const *required_features,
                                          uintptr_t required_features_length,
                                          const struct CanvasGPUSupportedLimits *required_limits,
-                                         void (*callback)(char*, struct CanvasGPUDevice*, void*),
+                                         void (*callback)(char*,
+                                                          const struct CanvasGPUDevice*,
+                                                          void*),
                                          void *callback_data);
 
 uint32_t canvas_native_webgpu_buffer_usage(const struct CanvasGPUBuffer *buffer);
 
 uint64_t canvas_native_webgpu_buffer_size(const struct CanvasGPUBuffer *buffer);
 
-char *canvas_native_webgpu_buffer_get_mapped_range(const struct CanvasGPUBuffer *buffer,
-                                                   int64_t offset,
-                                                   int64_t size,
-                                                   uint8_t *dst,
-                                                   uintptr_t dst_size);
+void canvas_native_webgpu_buffer_get_mapped_range(const struct CanvasGPUBuffer *buffer,
+                                                  int64_t offset,
+                                                  int64_t size,
+                                                  uint8_t *dst,
+                                                  uintptr_t dst_size);
 
 void canvas_native_webgpu_buffer_destroy(const struct CanvasGPUBuffer *buffer);
 
@@ -4141,95 +4435,173 @@ void canvas_native_webgpu_buffer_map_async(const struct CanvasGPUBuffer *buffer,
                                            void (*callback)(char*, void*),
                                            void *callback_data);
 
-struct CanvasGPUComputePass *canvas_native_webgpu_command_encoder_begin_compute_pass(struct CanvasGPUCommandEncoder *command_encoder,
-                                                                                     const struct CanvasGPUQuerySet *query_set,
-                                                                                     const char *label,
-                                                                                     int32_t beginning_of_pass_write_index,
-                                                                                     int32_t end_of_pass_write_index);
-
-struct CanvasGPURenderPass *canvas_native_webgpu_command_encoder_begin_render_pass(struct CanvasGPUCommandEncoder *command_encoder,
-                                                                                   const char *label,
-                                                                                   const struct CanvasRenderPassColorAttachment *color_attachments,
-                                                                                   uintptr_t color_attachments_size,
-                                                                                   const struct CanvasRenderPassDepthStencilAttachment *depth_stencil_attachment,
-                                                                                   const struct CanvasGPUQuerySet *occlusion_query_set,
-                                                                                   const struct CanvasGPUQuerySet *query_set,
-                                                                                   int32_t beginning_of_pass_write_index,
-                                                                                   int32_t end_of_pass_write_index);
-
-void canvas_native_webgpu_command_encoder_clear_buffer(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_reference(const struct CanvasGPUCommandEncoder *command_encoder);
+
+void canvas_native_webgpu_command_encoder_release(const struct CanvasGPUCommandEncoder *command_encoder);
+
+const struct CanvasGPUComputePassEncoder *canvas_native_webgpu_command_encoder_begin_compute_pass(const struct CanvasGPUCommandEncoder *command_encoder,
+                                                                                                  const struct CanvasGPUQuerySet *query_set,
+                                                                                                  const char *label,
+                                                                                                  int32_t beginning_of_pass_write_index,
+                                                                                                  int32_t end_of_pass_write_index);
+
+const struct CanvasGPURenderPassEncoder *canvas_native_webgpu_command_encoder_begin_render_pass(const struct CanvasGPUCommandEncoder *command_encoder,
+                                                                                                const char *label,
+                                                                                                const struct CanvasRenderPassColorAttachment *color_attachments,
+                                                                                                uintptr_t color_attachments_size,
+                                                                                                const struct CanvasRenderPassDepthStencilAttachment *depth_stencil_attachment,
+                                                                                                const struct CanvasGPUQuerySet *occlusion_query_set,
+                                                                                                const struct CanvasGPUQuerySet *query_set,
+                                                                                                int32_t beginning_of_pass_write_index,
+                                                                                                int32_t end_of_pass_write_index);
+
+void canvas_native_webgpu_command_encoder_clear_buffer(const struct CanvasGPUCommandEncoder *command_encoder,
                                                        const struct CanvasGPUBuffer *buffer,
                                                        int64_t offset,
                                                        int64_t size);
 
-void canvas_native_webgpu_command_encoder_copy_buffer_to_buffer(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_copy_buffer_to_buffer(const struct CanvasGPUCommandEncoder *command_encoder,
                                                                 const struct CanvasGPUBuffer *src,
                                                                 int64_t src_offset,
                                                                 const struct CanvasGPUBuffer *dst,
                                                                 int64_t dst_offset,
                                                                 uint64_t size);
 
-void canvas_native_webgpu_command_encoder_copy_buffer_to_texture(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_copy_buffer_to_texture(const struct CanvasGPUCommandEncoder *command_encoder,
                                                                  const struct CanvasImageCopyBuffer *src,
                                                                  const struct CanvasImageCopyTexture *dst,
                                                                  const struct CanvasExtent3d *copy_size);
 
-void canvas_native_webgpu_command_encoder_copy_texture_to_buffer(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_copy_texture_to_buffer(const struct CanvasGPUCommandEncoder *command_encoder,
                                                                  const struct CanvasImageCopyTexture *src,
                                                                  const struct CanvasImageCopyBuffer *dst,
                                                                  const struct CanvasExtent3d *copy_size);
 
-void canvas_native_webgpu_command_encoder_copy_texture_to_texture(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_copy_texture_to_texture(const struct CanvasGPUCommandEncoder *command_encoder,
                                                                   const struct CanvasImageCopyTexture *src,
                                                                   const struct CanvasImageCopyTexture *dst,
                                                                   const struct CanvasExtent3d *copy_size);
 
-struct CanvasGPUCommandBuffer *canvas_native_webgpu_command_encoder_finish(struct CanvasGPUCommandEncoder *command_encoder,
-                                                                           const char *label);
+const struct CanvasGPUCommandBuffer *canvas_native_webgpu_command_encoder_finish(const struct CanvasGPUCommandEncoder *command_encoder,
+                                                                                 const char *label);
 
-void canvas_native_webgpu_command_encoder_pop_debug_group(struct CanvasGPUCommandEncoder *command_encoder);
+void canvas_native_webgpu_command_encoder_pop_debug_group(const struct CanvasGPUCommandEncoder *command_encoder);
 
-void canvas_native_webgpu_command_encoder_push_debug_group(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_push_debug_group(const struct CanvasGPUCommandEncoder *command_encoder,
                                                            const char *label);
 
-void canvas_native_webgpu_command_encoder_resolve_query_set(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_resolve_query_set(const struct CanvasGPUCommandEncoder *command_encoder,
                                                             const struct CanvasGPUQuerySet *query_set,
                                                             uint32_t first_query,
                                                             uint32_t query_count,
                                                             struct CanvasGPUBuffer *dst,
                                                             uint64_t dst_offset);
 
-void canvas_native_webgpu_command_encoder_write_timestamp(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_write_timestamp(const struct CanvasGPUCommandEncoder *command_encoder,
                                                           const struct CanvasGPUQuerySet *query_set,
                                                           uint32_t query_index);
 
+void canvas_native_webgpu_compute_pass_reference(const struct CanvasGPUComputePassEncoder *compute_pass);
+
+void canvas_native_webgpu_compute_pass_release(const struct CanvasGPUComputePassEncoder *compute_pass);
+
+void canvas_native_webgpu_compute_pass_dispatch_workgroups(const struct CanvasGPUComputePassEncoder *compute_pass,
+                                                           uint32_t workgroup_count_x,
+                                                           uint32_t workgroup_count_y,
+                                                           uint32_t workgroup_count_z);
+
+void canvas_native_webgpu_compute_pass_dispatch_workgroups_indirect(const struct CanvasGPUComputePassEncoder *compute_pass,
+                                                                    const struct CanvasGPUBuffer *indirect_buffer,
+                                                                    uintptr_t indirect_offset);
+
+void canvas_native_webgpu_compute_pass_end(const struct CanvasGPUComputePassEncoder *compute_pass);
+
+void canvas_native_webgpu_compute_pass_insert_debug_marker(const struct CanvasGPUComputePassEncoder *compute_pass,
+                                                           const char *label);
+
+void canvas_native_webgpu_compute_pass_pop_debug_group(const struct CanvasGPUComputePassEncoder *compute_pass);
+
+void canvas_native_webgpu_compute_pass_push_debug_group(const struct CanvasGPUComputePassEncoder *compute_pass,
+                                                        const char *label);
+
+void canvas_native_webgpu_compute_pass_set_bind_group(const struct CanvasGPUComputePassEncoder *compute_pass,
+                                                      uint32_t index,
+                                                      const struct CanvasGPUBindGroup *bind_group,
+                                                      const uint32_t *dynamic_offsets,
+                                                      uintptr_t dynamic_offsets_size,
+                                                      uintptr_t dynamic_offsets_start,
+                                                      uintptr_t dynamic_offsets_length);
+
+void canvas_native_webgpu_compute_pass_set_pipeline(struct CanvasGPUComputePassEncoder *compute_pass,
+                                                    const struct CanvasGPUComputePipeline *pipeline);
+
 struct StringBuffer *canvas_native_webgpu_device_get_features(const struct CanvasGPUDevice *device);
 
 struct CanvasGPUSupportedLimits *canvas_native_webgpu_device_get_limits(const struct CanvasGPUDevice *device);
 
-struct CanvasGPUQueue *canvas_native_webgpu_device_get_queue(const struct CanvasGPUDevice *device);
+const struct CanvasGPUQueue *canvas_native_webgpu_device_get_queue(const struct CanvasGPUDevice *device);
 
 void canvas_native_webgpu_device_set_lost_callback(const struct CanvasGPUDevice *device,
                                                    void (*callback)(int32_t, char*, void*),
-                                                   void *callback_data);
+                                                   void *userdata);
 
 void canvas_native_webgpu_device_destroy(const struct CanvasGPUDevice *device);
 
-void canvas_native_webgpu_device_destroy_destory(struct CanvasGPUDevice *device);
+void canvas_native_webgpu_device_reference(const struct CanvasGPUDevice *device);
 
-struct CanvasGPUCommandEncoder *canvas_native_webgpu_device_create_command_encoder(const struct CanvasGPUDevice *device,
-                                                                                   const char *label);
+void canvas_native_webgpu_device_release(const struct CanvasGPUDevice *device);
 
-struct CanvasGPUShaderModule *canvas_native_webgpu_device_create_shader_module(const struct CanvasGPUDevice *device,
+const struct CanvasGPUBindGroupLayout *canvas_native_webgpu_device_create_bind_group_layout(const struct CanvasGPUDevice *device,
+                                                                                            const char *label,
+                                                                                            const struct CanvasBindGroupLayoutEntry *entries,
+                                                                                            uintptr_t size);
+
+const struct CanvasGPUBindGroup *canvas_native_webgpu_device_create_bind_group(const struct CanvasGPUDevice *device,
                                                                                const char *label,
-                                                                               const char *source);
+                                                                               const struct CanvasGPUBindGroupLayout *layout,
+                                                                               const struct CanvasBindGroupEntry *entries,
+                                                                               uintptr_t size);
+
+const struct CanvasGPUCommandEncoder *canvas_native_webgpu_device_create_command_encoder(const struct CanvasGPUDevice *device,
+                                                                                         const char *label);
+
+const struct CanvasGPUComputePipeline *canvas_native_webgpu_device_create_compute_pipeline(const struct CanvasGPUDevice *device,
+                                                                                           const char *label,
+                                                                                           struct CanvasGPUPipelineLayoutOrGPUAutoLayoutMode layout,
+                                                                                           const struct CanvasProgrammableStage *compute);
+
+void canvas_native_webgpu_device_create_compute_pipeline_async(const struct CanvasGPUDevice *device,
+                                                               const char *label,
+                                                               struct CanvasGPUPipelineLayoutOrGPUAutoLayoutMode layout,
+                                                               const struct CanvasProgrammableStage *compute,
+                                                               void (*callback)(const struct CanvasGPUComputePipeline*,
+                                                                                enum CanvasGPUErrorType,
+                                                                                char*,
+                                                                                void*),
+                                                               void *callback_data);
+
+const struct CanvasGPUPipelineLayout *canvas_native_webgpu_device_create_pipeline_layout(const struct CanvasGPUDevice *device,
+                                                                                         const char *label,
+                                                                                         const struct CanvasGPUBindGroupLayout *group_layouts,
+                                                                                         uintptr_t size);
+
+const struct CanvasGPUQuerySet *canvas_native_webgpu_device_create_query_set(const struct CanvasGPUDevice *device,
+                                                                             const char *label,
+                                                                             enum CanvasQueryType type_,
+                                                                             uint32_t count);
+
+const struct CanvasGPURenderBundleEncoder *canvas_native_webgpu_device_create_render_bundle_encoder(const struct CanvasGPUDevice *device,
+                                                                                                    const struct CanvasCreateRenderBundleEncoderDescriptor *descriptor);
+
+const struct CanvasGPUShaderModule *canvas_native_webgpu_device_create_shader_module(const struct CanvasGPUDevice *device,
+                                                                                     const char *label,
+                                                                                     const char *source);
 
-struct CanvasGPUBuffer *canvas_native_webgpu_device_create_buffer(const struct CanvasGPUDevice *device,
-                                                                  const char *label,
-                                                                  uint64_t size,
-                                                                  uint32_t usage,
-                                                                  bool mapped_at_creation,
-                                                                  char *error);
+const struct CanvasGPUBuffer *canvas_native_webgpu_device_create_buffer(const struct CanvasGPUDevice *device,
+                                                                        const char *label,
+                                                                        uint64_t size,
+                                                                        uint32_t usage,
+                                                                        bool mapped_at_creation);
 
 struct CanvasConstants *canvas_native_webgpu_constants_create(void);
 
@@ -4239,35 +4611,45 @@ void canvas_native_webgpu_constants_insert(struct CanvasConstants *constants,
 
 void canvas_native_webgpu_constants_destroy(struct CanvasConstants *constants);
 
-struct CanvasGPURenderPipeline *canvas_native_webgpu_device_create_render_pipeline(const struct CanvasGPUDevice *device,
-                                                                                   const struct CanvasCreateRenderPipelineDescriptor *descriptor);
+const struct CanvasGPURenderPipeline *canvas_native_webgpu_device_create_render_pipeline(const struct CanvasGPUDevice *device,
+                                                                                         const struct CanvasCreateRenderPipelineDescriptor *descriptor);
 
-struct CanvasGPUTexture *canvas_native_webgpu_device_create_texture(const struct CanvasGPUDevice *device,
-                                                                    const struct CanvasCreateTextureDescriptor *descriptor,
-                                                                    char *error);
+void canvas_native_webgpu_device_create_render_pipeline_async(const struct CanvasGPUDevice *device,
+                                                              const struct CanvasCreateRenderPipelineDescriptor *descriptor,
+                                                              void (*callback)(const struct CanvasGPURenderPipeline*,
+                                                                               enum CanvasGPUErrorType,
+                                                                               char*,
+                                                                               void*),
+                                                              void *callback_data);
 
-void canvas_native_webgpu_queue_copy_external_image_to_texture(struct CanvasGPUQueue *queue,
+const struct CanvasGPUTexture *canvas_native_webgpu_device_create_texture(const struct CanvasGPUDevice *device,
+                                                                          const struct CanvasCreateTextureDescriptor *descriptor);
+
+const struct CanvasGPUSampler *canvas_native_webgpu_device_create_sampler(const struct CanvasGPUDevice *device,
+                                                                          const struct CanvasCreateSamplerDescriptor *descriptor);
+
+void canvas_native_webgpu_queue_copy_external_image_to_texture(const struct CanvasGPUQueue *queue,
                                                                const struct CanvasImageCopyExternalImage *source,
                                                                const struct CanvasImageCopyTexture *destination,
                                                                const struct CanvasExtent3d *size);
 
-void canvas_native_webgpu_queue_on_submitted_work_done(struct CanvasGPUQueue *queue,
+void canvas_native_webgpu_queue_on_submitted_work_done(const struct CanvasGPUQueue *queue,
                                                        void (*callback)(char*, void*),
                                                        void *callback_data);
 
-void canvas_native_webgpu_queue_submit(struct CanvasGPUQueue *queue,
+void canvas_native_webgpu_queue_submit(const struct CanvasGPUQueue *queue,
                                        const struct CanvasGPUCommandBuffer *const *command_buffers,
                                        uintptr_t command_buffers_size);
 
-void canvas_native_webgpu_queue_write_buffer(struct CanvasGPUQueue *queue,
-                                             struct CanvasGPUBuffer *buffer,
+void canvas_native_webgpu_queue_write_buffer(const struct CanvasGPUQueue *queue,
+                                             const struct CanvasGPUBuffer *buffer,
                                              uint64_t buffer_offset,
                                              const uint8_t *data,
                                              uintptr_t data_size,
                                              uintptr_t data_offset,
                                              intptr_t size);
 
-void canvas_native_webgpu_queue_write_texture(struct CanvasGPUQueue *queue,
+void canvas_native_webgpu_queue_write_texture(const struct CanvasGPUQueue *queue,
                                               const struct CanvasImageCopyTexture *destination,
                                               const struct CanvasImageDataLayout *data_layout,
                                               const struct CanvasExtent3d *size,
@@ -4276,49 +4658,49 @@ void canvas_native_webgpu_queue_write_texture(struct CanvasGPUQueue *queue,
 
 struct CanvasGPUSupportedLimits *canvas_native_webgpu_create_limits(void);
 
-void canvas_native_webgpu_limits_destroy(struct CanvasGPUSupportedLimits *limits);
+void canvas_native_webgpu_limits_release(struct CanvasGPUSupportedLimits *limits);
 
-void canvas_native_webgpu_render_pass_begin_occlusion_query(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_begin_occlusion_query(const struct CanvasGPURenderPassEncoder *render_pass,
                                                             uint32_t query_index);
 
-void canvas_native_webgpu_render_pass_encoder_draw(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_encoder_draw(const struct CanvasGPURenderPassEncoder *render_pass,
                                                    uint32_t vertex_count,
                                                    uint32_t instance_count,
                                                    uint32_t first_vertex,
                                                    uint32_t first_instance);
 
-void canvas_native_webgpu_render_pass_draw_indexed(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_draw_indexed(const struct CanvasGPURenderPassEncoder *render_pass,
                                                    uint32_t index_count,
                                                    uint32_t instance_count,
                                                    uint32_t first_index,
                                                    int32_t base_vertex,
                                                    uint32_t first_instance);
 
-void canvas_native_webgpu_render_pass_draw_indexed_indirect(struct CanvasGPURenderPass *render_pass,
-                                                            struct CanvasGPUBuffer *indirect_buffer,
+void canvas_native_webgpu_render_pass_draw_indexed_indirect(const struct CanvasGPURenderPassEncoder *render_pass,
+                                                            const struct CanvasGPUBuffer *indirect_buffer,
                                                             uint64_t indirect_offset);
 
-void canvas_native_webgpu_render_pass_draw_indirect(struct CanvasGPURenderPass *render_pass,
-                                                    struct CanvasGPUBuffer *indirect_buffer,
+void canvas_native_webgpu_render_pass_draw_indirect(const struct CanvasGPURenderPassEncoder *render_pass,
+                                                    const struct CanvasGPUBuffer *indirect_buffer,
                                                     uint64_t indirect_offset);
 
-void canvas_native_webgpu_render_pass_end(struct CanvasGPURenderPass *render_pass);
+void canvas_native_webgpu_render_pass_end(const struct CanvasGPURenderPassEncoder *render_pass);
 
-void canvas_native_webgpu_render_pass_end_occlusion_query(struct CanvasGPURenderPass *render_pass);
+void canvas_native_webgpu_render_pass_end_occlusion_query(const struct CanvasGPURenderPassEncoder *render_pass);
 
-void canvas_native_webgpu_render_pass_execute_bundles(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_execute_bundles(const struct CanvasGPURenderPassEncoder *render_pass,
                                                       const struct CanvasGPURenderBundle *bundles,
                                                       uintptr_t bundles_size);
 
-void canvas_native_webgpu_render_pass_insert_debug_marker(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_insert_debug_marker(const struct CanvasGPURenderPassEncoder *render_pass,
                                                           const char *label);
 
-void canvas_native_webgpu_render_pass_pop_debug_group(struct CanvasGPURenderPass *render_pass);
+void canvas_native_webgpu_render_pass_pop_debug_group(const struct CanvasGPURenderPassEncoder *render_pass);
 
-void canvas_native_webgpu_render_pass_push_debug_group(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_push_debug_group(const struct CanvasGPURenderPassEncoder *render_pass,
                                                        const char *label);
 
-void canvas_native_webgpu_render_pass_set_bind_group(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_bind_group(const struct CanvasGPURenderPassEncoder *render_pass,
                                                      uint32_t index,
                                                      const struct CanvasGPUBindGroup *bind_group,
                                                      const uint32_t *dynamic_offsets,
@@ -4326,34 +4708,34 @@ void canvas_native_webgpu_render_pass_set_bind_group(struct CanvasGPURenderPass
                                                      uintptr_t dynamic_offsets_start,
                                                      uintptr_t dynamic_offsets_length);
 
-void canvas_native_webgpu_render_pass_set_blend_constant(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_blend_constant(const struct CanvasGPURenderPassEncoder *render_pass,
                                                          const struct CanvasColor *color);
 
-void canvas_native_webgpu_render_pass_set_index_buffer(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_index_buffer(const struct CanvasGPURenderPassEncoder *render_pass,
                                                        const struct CanvasGPUBuffer *buffer,
                                                        enum CanvasIndexFormat index_format,
                                                        int64_t offset,
                                                        int64_t size);
 
-void canvas_native_webgpu_render_pass_set_pipeline(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_pipeline(const struct CanvasGPURenderPassEncoder *render_pass,
                                                    const struct CanvasGPURenderPipeline *pipeline);
 
-void canvas_native_webgpu_render_pass_set_scissor_rect(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_scissor_rect(const struct CanvasGPURenderPassEncoder *render_pass,
                                                        uint32_t x,
                                                        uint32_t y,
                                                        uint32_t width,
                                                        uint32_t height);
 
-void canvas_native_webgpu_render_pass_set_stencil_reference(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_stencil_reference(const struct CanvasGPURenderPassEncoder *render_pass,
                                                             uint32_t reference);
 
-void canvas_native_webgpu_render_pass_set_vertex_buffer(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_vertex_buffer(const struct CanvasGPURenderPassEncoder *render_pass,
                                                         uint32_t slot,
-                                                        struct CanvasGPUBuffer *buffer,
+                                                        const struct CanvasGPUBuffer *buffer,
                                                         int64_t offset,
                                                         int64_t size);
 
-void canvas_native_webgpu_render_pass_set_viewport(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_viewport(const struct CanvasGPURenderPassEncoder *render_pass,
                                                    float x,
                                                    float y,
                                                    float width,
@@ -4361,73 +4743,105 @@ void canvas_native_webgpu_render_pass_set_viewport(struct CanvasGPURenderPass *r
                                                    float depth_min,
                                                    float depth_max);
 
+void canvas_native_webgpu_render_pass_reference(const struct CanvasGPURenderPassEncoder *render_pass);
+
+void canvas_native_webgpu_render_pass_release(const struct CanvasGPURenderPassEncoder *render_pass);
+
 #if defined(TARGET_OS_ANDROID)
-struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create(struct CanvasWebGPUInstance *instance,
-                                                                   void *window,
-                                                                   uint32_t width,
-                                                                   uint32_t height);
+const struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create(struct CanvasWebGPUInstance *instance,
+                                                                         void *window,
+                                                                         uint32_t width,
+                                                                         uint32_t height);
 #endif
 
 #if (defined(TARGET_OS_IOS) || defined(TARGET_OS_MACOS))
-struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create(struct CanvasWebGPUInstance *instance,
-                                                                   void *view,
-                                                                   uint32_t width,
-                                                                   uint32_t height);
+const struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create(const struct CanvasWebGPUInstance *instance,
+                                                                         void *view,
+                                                                         uint32_t width,
+                                                                         uint32_t height);
 #endif
 
 #if defined(TARGET_OS_IOS)
-struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create_uiview(struct CanvasWebGPUInstance *instance,
-                                                                          void *view,
-                                                                          uint32_t width,
-                                                                          uint32_t height);
+const struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create_uiview(const struct CanvasWebGPUInstance *instance,
+                                                                                void *view,
+                                                                                uint32_t width,
+                                                                                uint32_t height);
 #endif
 
 #if defined(TARGET_OS_MACOS)
-struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create_nsview(struct CanvasWebGPUInstance *instance,
-                                                                          void *view,
-                                                                          uint32_t width,
-                                                                          uint32_t height);
+const struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create_nsview(const struct CanvasWebGPUInstance *instance,
+                                                                                void *view,
+                                                                                uint32_t width,
+                                                                                uint32_t height);
 #endif
 
-void canvas_native_webgpu_context_configure(struct CanvasGPUCanvasContext *context,
-                                            struct CanvasGPUDevice *device,
+void canvas_native_webgpu_context_configure(const struct CanvasGPUCanvasContext *context,
+                                            const struct CanvasGPUDevice *device,
                                             const struct CanvasGPUSurfaceConfiguration *config);
 
-void canvas_native_webgpu_context_unconfigure(struct CanvasGPUCanvasContext *context,
+void canvas_native_webgpu_context_unconfigure(const struct CanvasGPUCanvasContext *context,
                                               struct CanvasGPUDevice *device,
                                               const struct CanvasGPUSurfaceConfiguration *config);
 
-struct CanvasGPUTexture *canvas_native_webgpu_context_get_current_texture(struct CanvasGPUCanvasContext *context);
+const struct CanvasGPUTexture *canvas_native_webgpu_context_get_current_texture(const struct CanvasGPUCanvasContext *context);
+
+void canvas_native_webgpu_context_present_surface(const struct CanvasGPUCanvasContext *context);
+
+void canvas_native_webgpu_context_get_capabilities(const struct CanvasGPUCanvasContext *context,
+                                                   const struct CanvasGPUAdapter *adapter);
 
 char *canvas_native_webgpu_enum_gpu_texture_to_string(struct CanvasGPUTextureFormat value);
 
 struct CanvasOptionalGPUTextureFormat canvas_native_webgpu_string_to_gpu_texture_enum(const char *format);
 
-struct CanvasGPUTextureView *canvas_native_webgpu_texture_create_texture_view(struct CanvasGPUTexture *texture,
-                                                                              const struct CanvasCreateTextureViewDescriptor *descriptor);
+void canvas_native_webgpu_texture_reference(const struct CanvasGPUTexture *texture);
+
+void canvas_native_webgpu_texture_release(const struct CanvasGPUTexture *texture);
+
+const struct CanvasGPUTextureView *canvas_native_webgpu_texture_create_texture_view(const struct CanvasGPUTexture *texture,
+                                                                                    const struct CanvasCreateTextureViewDescriptor *descriptor);
+
+uint32_t canvas_native_webgpu_texture_get_depth_or_array_layers(const struct CanvasGPUTexture *texture);
+
+uint32_t canvas_native_webgpu_texture_get_width(const struct CanvasGPUTexture *texture);
+
+uint32_t canvas_native_webgpu_texture_get_height(const struct CanvasGPUTexture *texture);
+
+enum CanvasTextureDimension canvas_native_webgpu_texture_get_dimension(const struct CanvasGPUTexture *texture);
+
+struct CanvasGPUTextureFormat canvas_native_webgpu_texture_get_format(const struct CanvasGPUTexture *texture);
+
+uint32_t canvas_native_webgpu_texture_get_usage(const struct CanvasGPUTexture *texture);
+
+char *canvas_native_webgpu_texture_get_label(const struct CanvasGPUTexture *_texture);
+
+uint32_t canvas_native_webgpu_texture_get_mip_level_count(const struct CanvasGPUTexture *texture);
+
+uint32_t canvas_native_webgpu_texture_get_sample_count(const struct CanvasGPUTexture *texture);
 
-uint32_t canvas_native_webgpu_texture_get_depth_or_array_layers(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_texture_destroy(const struct CanvasGPUTexture *texture);
 
-uint32_t canvas_native_webgpu_texture_get_width(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_texture_view_reference(const struct CanvasGPUTextureView *texture_view);
 
-uint32_t canvas_native_webgpu_texture_get_height(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_texture_view_release(const struct CanvasGPUTextureView *texture_view);
 
-enum CanvasTextureDimension canvas_native_webgpu_texture_get_dimension(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_bind_group_reference(const struct CanvasGPUBindGroup *bind_group);
 
-struct CanvasGPUTextureFormat canvas_native_webgpu_texture_get_format(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_bind_group_release(const struct CanvasGPUBindGroup *bind_group);
 
-uint32_t canvas_native_webgpu_texture_get_usage(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_bind_group_layout_reference(const struct CanvasGPUBindGroupLayout *bind_group_layout);
 
-char *canvas_native_webgpu_texture_get_label(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_bind_group_layout_release(const struct CanvasGPUBindGroupLayout *bind_group_layout);
 
-uint32_t canvas_native_webgpu_texture_get_mip_level_count(struct CanvasGPUTexture *texture);
+const struct CanvasGPUBindGroupLayout *canvas_native_webgpu_render_pipeline_get_bind_group_layout(const struct CanvasGPURenderPipeline *pipeline,
+                                                                                                  uint32_t index);
 
-uint32_t canvas_native_webgpu_texture_get_sample_count(struct CanvasGPUTexture *texture);
+enum CanvasGPUErrorType canvas_native_webgpu_error_get_type(const struct CanvasGPUError *error);
 
-char *canvas_native_webgpu_texture_destroy(struct CanvasGPUTexture *texture);
+char *canvas_native_webgpu_error_get_message(const struct CanvasGPUError *error);
 
-struct CanvasGPUBindGroupLayout *canvas_native_webgpu_render_pipeline_get_bind_group_layout(const struct CanvasGPURenderPipeline *pipeline,
-                                                                                            uint32_t index);
+const struct CanvasGPUBindGroupLayout *canvas_native_webgpu_compute_pipeline_get_bind_group_layout(const struct CanvasGPUComputePipeline *pipeline,
+                                                                                                   uint32_t index);
 
 const uint8_t *canvas_native_u8_buffer_get_bytes(const struct U8Buffer *buffer);
 
diff --git a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/Info.plist b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/Info.plist
index e18dd57e0..d423fbd38 100644
--- a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/Info.plist
+++ b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/Info.plist
@@ -10,18 +10,15 @@
 			<key>DebugSymbolsPath</key>
 			<string>dSYMs</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64_x86_64-simulator</string>
+			<string>ios-arm64</string>
 			<key>LibraryPath</key>
 			<string>CanvasNative.framework</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
-				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
-			<key>SupportedPlatformVariant</key>
-			<string>simulator</string>
 		</dict>
 		<dict>
 			<key>BinaryPath</key>
@@ -29,15 +26,18 @@
 			<key>DebugSymbolsPath</key>
 			<string>dSYMs</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64</string>
+			<string>ios-arm64_x86_64-simulator</string>
 			<key>LibraryPath</key>
 			<string>CanvasNative.framework</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
+				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
 		</dict>
 	</array>
 	<key>CFBundlePackageType</key>
diff --git a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/CanvasNative b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/CanvasNative
index 062b590f4..c6793de12 100755
Binary files a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/CanvasNative and b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/CanvasNative differ
diff --git a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/Headers/canvas_native.h b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/Headers/canvas_native.h
index b299e05f8..bdf2fa39e 100644
--- a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/Headers/canvas_native.h
+++ b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64/CanvasNative.framework/Headers/canvas_native.h
@@ -8,6 +8,38 @@
 #include <stdint.h>
 #include <stdlib.h>
 
+typedef enum CanvasAddressMode {
+  /**
+   * Clamp the value to the edge of the texture
+   *
+   * -0.25 -> 0.0
+   * 1.25  -> 1.0
+   */
+  CanvasAddressModeClampToEdge = 0,
+  /**
+   * Repeat the texture in a tiling fashion
+   *
+   * -0.25 -> 0.75
+   * 1.25 -> 0.25
+   */
+  CanvasAddressModeRepeat = 1,
+  /**
+   * Repeat the texture, mirroring it every repeat
+   *
+   * -0.25 -> 0.25
+   * 1.25 -> 0.75
+   */
+  CanvasAddressModeMirrorRepeat = 2,
+  /**
+   * Clamp the value to the border of the texture
+   * Requires feature [`Features::ADDRESS_MODE_CLAMP_TO_BORDER`]
+   *
+   * -0.25 -> border
+   * 1.25 -> border
+   */
+  CanvasAddressModeClampToBorder = 3,
+} CanvasAddressMode;
+
 /**
  * ASTC block dimensions
  */
@@ -188,6 +220,12 @@ typedef enum CanvasBlendOperation {
   CanvasBlendOperationMax = 4,
 } CanvasBlendOperation;
 
+typedef enum CanvasBufferBindingType {
+  CanvasBufferBindingTypeUniform,
+  CanvasBufferBindingTypeStorage,
+  CanvasBufferBindingTypeReadOnlyStorage,
+} CanvasBufferBindingType;
+
 typedef enum CanvasCompareFunction {
   CanvasCompareFunctionNever = 1,
   CanvasCompareFunctionLess = 2,
@@ -205,6 +243,16 @@ typedef enum CanvasCullMode {
   CanvasCullModeBack,
 } CanvasCullMode;
 
+typedef enum CanvasFilterMode {
+  CanvasFilterModeNearest = 0,
+  /**
+   * Linear Interpolation
+   *
+   * This makes textures smooth but blurry when used as a mag filter.
+   */
+  CanvasFilterModeLinear = 1,
+} CanvasFilterMode;
+
 typedef enum CanvasFrontFace {
   CanvasFrontFaceCcw = 0,
   CanvasFrontFaceCw = 1,
@@ -214,6 +262,14 @@ typedef enum CanvasGPUAutoLayoutMode {
   CanvasGPUAutoLayoutModeAuto,
 } CanvasGPUAutoLayoutMode;
 
+typedef enum CanvasGPUErrorType {
+  CanvasGPUErrorTypeNone,
+  CanvasGPUErrorTypeLost,
+  CanvasGPUErrorTypeOutOfMemory,
+  CanvasGPUErrorTypeValidation,
+  CanvasGPUErrorTypeInternal,
+} CanvasGPUErrorType;
+
 typedef enum CanvasGPUPowerPreference {
   CanvasGPUPowerPreferenceNone,
   CanvasGPUPowerPreferenceLowPower,
@@ -271,6 +327,28 @@ typedef enum CanvasPrimitiveTopology {
   CanvasPrimitiveTopologyTriangleStrip = 4,
 } CanvasPrimitiveTopology;
 
+typedef enum CanvasQueryType {
+  CanvasQueryTypeOcclusion,
+  CanvasQueryTypeTimestamp,
+} CanvasQueryType;
+
+typedef enum CanvasSamplerBindingType {
+  /**
+   * The sampling result is produced based on more than a single color sample from a texture,
+   * e.g. when bilinear interpolation is enabled.
+   */
+  CanvasSamplerBindingTypeFiltering,
+  /**
+   * The sampling result is produced based on a single color sample from a texture.
+   */
+  CanvasSamplerBindingTypeNonFiltering,
+  /**
+   * Use as a comparison sampler instead of a normal sampler.
+   * For more info take a look at the analogous functionality in OpenGL: <https://www.khronos.org/opengl/wiki/Sampler_Object#Comparison_mode>.
+   */
+  CanvasSamplerBindingTypeComparison,
+} CanvasSamplerBindingType;
+
 typedef enum CanvasStencilOperation {
   CanvasStencilOperationKeep = 0,
   CanvasStencilOperationZero = 1,
@@ -282,6 +360,64 @@ typedef enum CanvasStencilOperation {
   CanvasStencilOperationDecrementWrap = 7,
 } CanvasStencilOperation;
 
+typedef enum CanvasStorageTextureAccess {
+  /**
+   * The texture can only be written in the shader and it:
+   * - may or may not be annotated with `write` (WGSL).
+   * - must be annotated with `writeonly` (GLSL).
+   *
+   * Example WGSL syntax:
+   * ```rust,ignore
+   * @group(0) @binding(0)
+   * var my_storage_image: texture_storage_2d<f32, write>;
+   * ```
+   *
+   * Example GLSL syntax:
+   * ```cpp,ignore
+   * layout(set=0, binding=0, r32f) writeonly uniform image2D myStorageImage;
+   * ```
+   */
+  CanvasStorageTextureAccessWriteOnly,
+  /**
+   * The texture can only be read in the shader and it must be annotated with `read` (WGSL) or
+   * `readonly` (GLSL).
+   *
+   * [`Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES`] must be enabled to use this access
+   * mode. This is a native-only extension.
+   *
+   * Example WGSL syntax:
+   * ```rust,ignore
+   * @group(0) @binding(0)
+   * var my_storage_image: texture_storage_2d<f32, read>;
+   * ```
+   *
+   * Example GLSL syntax:
+   * ```cpp,ignore
+   * layout(set=0, binding=0, r32f) readonly uniform image2D myStorageImage;
+   * ```
+   */
+  CanvasStorageTextureAccessReadOnly,
+  /**
+   * The texture can be both read and written in the shader and must be annotated with
+   * `read_write` in WGSL.
+   *
+   * [`Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES`] must be enabled to use this access
+   * mode.  This is a nonstandard, native-only extension.
+   *
+   * Example WGSL syntax:
+   * ```rust,ignore
+   * @group(0) @binding(0)
+   * var my_storage_image: texture_storage_2d<f32, read_write>;
+   * ```
+   *
+   * Example GLSL syntax:
+   * ```cpp,ignore
+   * layout(set=0, binding=0, r32f) uniform image2D myStorageImage;
+   * ```
+   */
+  CanvasStorageTextureAccessReadWrite,
+} CanvasStorageTextureAccess;
+
 typedef enum CanvasStoreOp {
   CanvasStoreOpDiscard = 0,
   CanvasStoreOpStore = 1,
@@ -320,6 +456,23 @@ typedef enum CanvasTextureDimension {
   CanvasTextureDimensionD3,
 } CanvasTextureDimension;
 
+typedef enum CanvasTextureSampleType {
+  CanvasTextureSampleTypeFloat,
+  CanvasTextureSampleTypeUnfilterableFloat,
+  CanvasTextureSampleTypeDepth,
+  CanvasTextureSampleTypeSint,
+  CanvasTextureSampleTypeUint,
+} CanvasTextureSampleType;
+
+typedef enum CanvasTextureViewDimension {
+  CanvasTextureViewDimensionD1,
+  CanvasTextureViewDimensionD2,
+  CanvasTextureViewDimensionD2Array,
+  CanvasTextureViewDimensionCube,
+  CanvasTextureViewDimensionCubeArray,
+  CanvasTextureViewDimensionD3,
+} CanvasTextureViewDimension;
+
 typedef enum CanvasVertexFormat {
   CanvasVertexFormatUint8x2 = 0,
   CanvasVertexFormatUint8x4 = 1,
@@ -478,10 +631,14 @@ typedef struct CanvasGPUCommandBuffer CanvasGPUCommandBuffer;
 
 typedef struct CanvasGPUCommandEncoder CanvasGPUCommandEncoder;
 
-typedef struct CanvasGPUComputePass CanvasGPUComputePass;
+typedef struct CanvasGPUComputePassEncoder CanvasGPUComputePassEncoder;
+
+typedef struct CanvasGPUComputePipeline CanvasGPUComputePipeline;
 
 typedef struct CanvasGPUDevice CanvasGPUDevice;
 
+typedef struct CanvasGPUError CanvasGPUError;
+
 typedef struct CanvasGPUPipelineLayout CanvasGPUPipelineLayout;
 
 typedef struct CanvasGPUQuerySet CanvasGPUQuerySet;
@@ -490,10 +647,14 @@ typedef struct CanvasGPUQueue CanvasGPUQueue;
 
 typedef struct CanvasGPURenderBundle CanvasGPURenderBundle;
 
-typedef struct CanvasGPURenderPass CanvasGPURenderPass;
+typedef struct CanvasGPURenderBundleEncoder CanvasGPURenderBundleEncoder;
+
+typedef struct CanvasGPURenderPassEncoder CanvasGPURenderPassEncoder;
 
 typedef struct CanvasGPURenderPipeline CanvasGPURenderPipeline;
 
+typedef struct CanvasGPUSampler CanvasGPUSampler;
+
 typedef struct CanvasGPUShaderModule CanvasGPUShaderModule;
 
 typedef struct CanvasGPUTexture CanvasGPUTexture;
@@ -726,65 +887,21 @@ typedef struct CanvasExtent3d {
   uint32_t depth_or_array_layers;
 } CanvasExtent3d;
 
-typedef enum CanvasGPUPipelineLayoutOrGPUAutoLayoutMode_Tag {
-  CanvasGPUPipelineLayoutOrGPUAutoLayoutModeLayout,
-  CanvasGPUPipelineLayoutOrGPUAutoLayoutModeAuto,
-} CanvasGPUPipelineLayoutOrGPUAutoLayoutMode_Tag;
+typedef struct CanvasBufferBindingLayout {
+  enum CanvasBufferBindingType type_;
+  bool has_dynamic_offset;
+  int64_t min_binding_size;
+} CanvasBufferBindingLayout;
 
-typedef struct CanvasGPUPipelineLayoutOrGPUAutoLayoutMode {
-  CanvasGPUPipelineLayoutOrGPUAutoLayoutMode_Tag tag;
-  union {
-    struct {
-      const struct CanvasGPUPipelineLayout *layout;
-    };
-    struct {
-      enum CanvasGPUAutoLayoutMode auto_;
-    };
-  };
-} CanvasGPUPipelineLayoutOrGPUAutoLayoutMode;
-
-typedef struct CanvasVertexAttribute {
-  enum CanvasVertexFormat format;
-  uint64_t offset;
-  uint32_t shader_location;
-} CanvasVertexAttribute;
-
-typedef struct CanvasVertexBufferLayout {
-  uint64_t array_stride;
-  enum CanvasVertexStepMode step_mode;
-  const struct CanvasVertexAttribute *attributes;
-  uintptr_t attributes_size;
-} CanvasVertexBufferLayout;
+typedef struct CanvasSamplerBindingLayout {
+  enum CanvasSamplerBindingType type_;
+} CanvasSamplerBindingLayout;
 
-typedef struct CanvasVertexState {
-  const struct CanvasGPUShaderModule *module;
-  const char *entry_point;
-  const struct CanvasConstants *constants;
-  const struct CanvasVertexBufferLayout *buffers;
-  uintptr_t buffers_size;
-} CanvasVertexState;
-
-typedef enum CanvasOptionalIndexFormat_Tag {
-  CanvasOptionalIndexFormatNone,
-  CanvasOptionalIndexFormatSome,
-} CanvasOptionalIndexFormat_Tag;
-
-typedef struct CanvasOptionalIndexFormat {
-  CanvasOptionalIndexFormat_Tag tag;
-  union {
-    struct {
-      enum CanvasIndexFormat some;
-    };
-  };
-} CanvasOptionalIndexFormat;
-
-typedef struct CanvasPrimitiveState {
-  enum CanvasPrimitiveTopology topology;
-  struct CanvasOptionalIndexFormat strip_index_format;
-  enum CanvasFrontFace front_face;
-  enum CanvasCullMode cull_mode;
-  bool unclipped_depth;
-} CanvasPrimitiveState;
+typedef struct CanvasTextureBindingLayout {
+  enum CanvasTextureSampleType sample_type;
+  enum CanvasTextureViewDimension view_dimension;
+  bool multisampled;
+} CanvasTextureBindingLayout;
 
 typedef enum CanvasGPUTextureFormat_Tag {
   /**
@@ -1237,6 +1354,151 @@ typedef struct CanvasGPUTextureFormat {
   };
 } CanvasGPUTextureFormat;
 
+typedef struct CanvasStorageTextureBindingLayout {
+  enum CanvasStorageTextureAccess access;
+  struct CanvasGPUTextureFormat format;
+  enum CanvasTextureViewDimension view_dimension;
+} CanvasStorageTextureBindingLayout;
+
+typedef enum CanvasBindingType_Tag {
+  CanvasBindingTypeBuffer,
+  CanvasBindingTypeSampler,
+  CanvasBindingTypeTexture,
+  CanvasBindingTypeStorageTexture,
+} CanvasBindingType_Tag;
+
+typedef struct CanvasBindingType {
+  CanvasBindingType_Tag tag;
+  union {
+    struct {
+      struct CanvasBufferBindingLayout buffer;
+    };
+    struct {
+      struct CanvasSamplerBindingLayout sampler;
+    };
+    struct {
+      struct CanvasTextureBindingLayout texture;
+    };
+    struct {
+      struct CanvasStorageTextureBindingLayout storage_texture;
+    };
+  };
+} CanvasBindingType;
+
+typedef struct CanvasBindGroupLayoutEntry {
+  uint32_t binding;
+  uint32_t visibility;
+  struct CanvasBindingType binding_type;
+} CanvasBindGroupLayoutEntry;
+
+typedef struct CanvasBufferBinding {
+  const struct CanvasGPUBuffer *buffer;
+  int64_t offset;
+  int64_t size;
+} CanvasBufferBinding;
+
+typedef enum CanvasBindGroupEntryResource_Tag {
+  CanvasBindGroupEntryResourceBuffer,
+  CanvasBindGroupEntryResourceSampler,
+  CanvasBindGroupEntryResourceTextureView,
+} CanvasBindGroupEntryResource_Tag;
+
+typedef struct CanvasBindGroupEntryResource {
+  CanvasBindGroupEntryResource_Tag tag;
+  union {
+    struct {
+      struct CanvasBufferBinding buffer;
+    };
+    struct {
+      const struct CanvasGPUSampler *sampler;
+    };
+    struct {
+      const struct CanvasGPUTextureView *texture_view;
+    };
+  };
+} CanvasBindGroupEntryResource;
+
+typedef struct CanvasBindGroupEntry {
+  uint32_t binding;
+  struct CanvasBindGroupEntryResource resource;
+} CanvasBindGroupEntry;
+
+typedef enum CanvasGPUPipelineLayoutOrGPUAutoLayoutMode_Tag {
+  CanvasGPUPipelineLayoutOrGPUAutoLayoutModeLayout,
+  CanvasGPUPipelineLayoutOrGPUAutoLayoutModeAuto,
+} CanvasGPUPipelineLayoutOrGPUAutoLayoutMode_Tag;
+
+typedef struct CanvasGPUPipelineLayoutOrGPUAutoLayoutMode {
+  CanvasGPUPipelineLayoutOrGPUAutoLayoutMode_Tag tag;
+  union {
+    struct {
+      const struct CanvasGPUPipelineLayout *layout;
+    };
+    struct {
+      enum CanvasGPUAutoLayoutMode auto_;
+    };
+  };
+} CanvasGPUPipelineLayoutOrGPUAutoLayoutMode;
+
+typedef struct CanvasProgrammableStage {
+  const struct CanvasGPUShaderModule *module;
+  const char *entry_point;
+  const struct CanvasConstants *constants;
+} CanvasProgrammableStage;
+
+typedef struct CanvasCreateRenderBundleEncoderDescriptor {
+  const char *label;
+  const struct CanvasGPUTextureFormat *color_formats;
+  uintptr_t color_formats_size;
+  const struct CanvasGPUTextureFormat *depth_stencil_format;
+  uint32_t sample_count;
+  bool depth_read_only;
+  bool stencil_read_only;
+} CanvasCreateRenderBundleEncoderDescriptor;
+
+typedef struct CanvasVertexAttribute {
+  enum CanvasVertexFormat format;
+  uint64_t offset;
+  uint32_t shader_location;
+} CanvasVertexAttribute;
+
+typedef struct CanvasVertexBufferLayout {
+  uint64_t array_stride;
+  enum CanvasVertexStepMode step_mode;
+  const struct CanvasVertexAttribute *attributes;
+  uintptr_t attributes_size;
+} CanvasVertexBufferLayout;
+
+typedef struct CanvasVertexState {
+  const struct CanvasGPUShaderModule *module;
+  const char *entry_point;
+  const struct CanvasConstants *constants;
+  const struct CanvasVertexBufferLayout *buffers;
+  uintptr_t buffers_size;
+} CanvasVertexState;
+
+typedef enum CanvasOptionalIndexFormat_Tag {
+  CanvasOptionalIndexFormatNone,
+  CanvasOptionalIndexFormatSome,
+} CanvasOptionalIndexFormat_Tag;
+
+typedef struct CanvasOptionalIndexFormat {
+  CanvasOptionalIndexFormat_Tag tag;
+  union {
+    struct {
+      enum CanvasIndexFormat some;
+    };
+  };
+} CanvasOptionalIndexFormat;
+
+typedef struct CanvasPrimitiveState {
+  enum CanvasPrimitiveTopology topology;
+  struct CanvasOptionalIndexFormat strip_index_format;
+  enum CanvasFrontFace front_face;
+  enum CanvasCullMode cull_mode;
+  bool unclipped_depth;
+} CanvasPrimitiveState;
+
 typedef struct CanvasStencilFaceState {
   enum CanvasCompareFunction compare;
   enum CanvasStencilOperation fail_op;
@@ -1356,6 +1618,34 @@ typedef struct CanvasCreateTextureDescriptor {
   uintptr_t view_formats_size;
 } CanvasCreateTextureDescriptor;
 
+typedef enum CanvasOptionalCompareFunction_Tag {
+  CanvasOptionalCompareFunctionNone,
+  CanvasOptionalCompareFunctionSome,
+} CanvasOptionalCompareFunction_Tag;
+
+typedef struct CanvasOptionalCompareFunction {
+  CanvasOptionalCompareFunction_Tag tag;
+  union {
+    struct {
+      enum CanvasCompareFunction some;
+    };
+  };
+} CanvasOptionalCompareFunction;
+
+typedef struct CanvasCreateSamplerDescriptor {
+  const char *label;
+  enum CanvasAddressMode address_mode_u;
+  enum CanvasAddressMode address_mode_v;
+  enum CanvasAddressMode address_mode_w;
+  enum CanvasFilterMode mag_filter;
+  enum CanvasFilterMode min_filter;
+  enum CanvasFilterMode mipmap_filter;
+  float lod_min_clamp;
+  float lod_max_clamp;
+  struct CanvasOptionalCompareFunction compare;
+  uint16_t max_anisotropy;
+} CanvasCreateSamplerDescriptor;
+
 typedef struct CanvasOrigin2d {
   /**
    *
@@ -4085,9 +4375,9 @@ void canvas_native_matrix_destroy(struct Matrix *value);
 
 void canvas_native_path_destroy(struct Path *value);
 
-struct CanvasWebGPUInstance *canvas_native_webgpu_instance_create(void);
+const struct CanvasWebGPUInstance *canvas_native_webgpu_instance_create(void);
 
-void canvas_native_webgpu_instance_destroy(struct CanvasWebGPUInstance *instance);
+void canvas_native_webgpu_instance_release(const struct CanvasWebGPUInstance *instance);
 
 void canvas_native_webgpu_request_adapter(const struct CanvasWebGPUInstance *instance,
                                           const struct CanvasGPURequestAdapterOptions *options,
@@ -4096,13 +4386,15 @@ void canvas_native_webgpu_request_adapter(const struct CanvasWebGPUInstance *ins
 
 char *canvas_native_webgpu_adapter_info_vendor(const struct CanvasGPUAdapterInfo *info);
 
-char *canvas_native_webgpu_adapter_info_architecture(const struct CanvasGPUAdapterInfo *info);
+char *canvas_native_webgpu_adapter_info_architecture(const struct CanvasGPUAdapterInfo *_info);
 
 char *canvas_native_webgpu_adapter_info_device(const struct CanvasGPUAdapterInfo *info);
 
 char *canvas_native_webgpu_adapter_info_description(const struct CanvasGPUAdapterInfo *info);
 
-void canvas_native_webgpu_adapter_info_destroy(struct CanvasGPUAdapterInfo *info);
+void canvas_native_webgpu_adapter_info_reference(const struct CanvasGPUAdapterInfo *info);
+
+void canvas_native_webgpu_adapter_info_release(const struct CanvasGPUAdapterInfo *info);
 
 struct StringBuffer *canvas_native_webgpu_adapter_get_features(const struct CanvasGPUAdapter *adapter);
 
@@ -4110,25 +4402,27 @@ bool canvas_native_webgpu_adapter_is_fallback_adapter(const struct CanvasGPUAdap
 
 struct CanvasGPUSupportedLimits *canvas_native_webgpu_adapter_get_limits(const struct CanvasGPUAdapter *adapter);
 
-struct CanvasGPUAdapterInfo *canvas_native_webgpu_request_adapter_info(struct CanvasGPUAdapter *adapter);
+const struct CanvasGPUAdapterInfo *canvas_native_webgpu_request_adapter_info(struct CanvasGPUAdapter *adapter);
 
-void canvas_native_webgpu_request_device(struct CanvasGPUAdapter *adapter,
+void canvas_native_webgpu_request_device(const struct CanvasGPUAdapter *adapter,
                                          const char *label,
                                          const char *const *required_features,
                                          uintptr_t required_features_length,
                                          const struct CanvasGPUSupportedLimits *required_limits,
-                                         void (*callback)(char*, struct CanvasGPUDevice*, void*),
+                                         void (*callback)(char*,
+                                                          const struct CanvasGPUDevice*,
+                                                          void*),
                                          void *callback_data);
 
 uint32_t canvas_native_webgpu_buffer_usage(const struct CanvasGPUBuffer *buffer);
 
 uint64_t canvas_native_webgpu_buffer_size(const struct CanvasGPUBuffer *buffer);
 
-char *canvas_native_webgpu_buffer_get_mapped_range(const struct CanvasGPUBuffer *buffer,
-                                                   int64_t offset,
-                                                   int64_t size,
-                                                   uint8_t *dst,
-                                                   uintptr_t dst_size);
+void canvas_native_webgpu_buffer_get_mapped_range(const struct CanvasGPUBuffer *buffer,
+                                                  int64_t offset,
+                                                  int64_t size,
+                                                  uint8_t *dst,
+                                                  uintptr_t dst_size);
 
 void canvas_native_webgpu_buffer_destroy(const struct CanvasGPUBuffer *buffer);
 
@@ -4141,95 +4435,173 @@ void canvas_native_webgpu_buffer_map_async(const struct CanvasGPUBuffer *buffer,
                                            void (*callback)(char*, void*),
                                            void *callback_data);
 
-struct CanvasGPUComputePass *canvas_native_webgpu_command_encoder_begin_compute_pass(struct CanvasGPUCommandEncoder *command_encoder,
-                                                                                     const struct CanvasGPUQuerySet *query_set,
-                                                                                     const char *label,
-                                                                                     int32_t beginning_of_pass_write_index,
-                                                                                     int32_t end_of_pass_write_index);
-
-struct CanvasGPURenderPass *canvas_native_webgpu_command_encoder_begin_render_pass(struct CanvasGPUCommandEncoder *command_encoder,
-                                                                                   const char *label,
-                                                                                   const struct CanvasRenderPassColorAttachment *color_attachments,
-                                                                                   uintptr_t color_attachments_size,
-                                                                                   const struct CanvasRenderPassDepthStencilAttachment *depth_stencil_attachment,
-                                                                                   const struct CanvasGPUQuerySet *occlusion_query_set,
-                                                                                   const struct CanvasGPUQuerySet *query_set,
-                                                                                   int32_t beginning_of_pass_write_index,
-                                                                                   int32_t end_of_pass_write_index);
-
-void canvas_native_webgpu_command_encoder_clear_buffer(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_reference(const struct CanvasGPUCommandEncoder *command_encoder);
+
+void canvas_native_webgpu_command_encoder_release(const struct CanvasGPUCommandEncoder *command_encoder);
+
+const struct CanvasGPUComputePassEncoder *canvas_native_webgpu_command_encoder_begin_compute_pass(const struct CanvasGPUCommandEncoder *command_encoder,
+                                                                                                  const struct CanvasGPUQuerySet *query_set,
+                                                                                                  const char *label,
+                                                                                                  int32_t beginning_of_pass_write_index,
+                                                                                                  int32_t end_of_pass_write_index);
+
+const struct CanvasGPURenderPassEncoder *canvas_native_webgpu_command_encoder_begin_render_pass(const struct CanvasGPUCommandEncoder *command_encoder,
+                                                                                                const char *label,
+                                                                                                const struct CanvasRenderPassColorAttachment *color_attachments,
+                                                                                                uintptr_t color_attachments_size,
+                                                                                                const struct CanvasRenderPassDepthStencilAttachment *depth_stencil_attachment,
+                                                                                                const struct CanvasGPUQuerySet *occlusion_query_set,
+                                                                                                const struct CanvasGPUQuerySet *query_set,
+                                                                                                int32_t beginning_of_pass_write_index,
+                                                                                                int32_t end_of_pass_write_index);
+
+void canvas_native_webgpu_command_encoder_clear_buffer(const struct CanvasGPUCommandEncoder *command_encoder,
                                                        const struct CanvasGPUBuffer *buffer,
                                                        int64_t offset,
                                                        int64_t size);
 
-void canvas_native_webgpu_command_encoder_copy_buffer_to_buffer(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_copy_buffer_to_buffer(const struct CanvasGPUCommandEncoder *command_encoder,
                                                                 const struct CanvasGPUBuffer *src,
                                                                 int64_t src_offset,
                                                                 const struct CanvasGPUBuffer *dst,
                                                                 int64_t dst_offset,
                                                                 uint64_t size);
 
-void canvas_native_webgpu_command_encoder_copy_buffer_to_texture(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_copy_buffer_to_texture(const struct CanvasGPUCommandEncoder *command_encoder,
                                                                  const struct CanvasImageCopyBuffer *src,
                                                                  const struct CanvasImageCopyTexture *dst,
                                                                  const struct CanvasExtent3d *copy_size);
 
-void canvas_native_webgpu_command_encoder_copy_texture_to_buffer(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_copy_texture_to_buffer(const struct CanvasGPUCommandEncoder *command_encoder,
                                                                  const struct CanvasImageCopyTexture *src,
                                                                  const struct CanvasImageCopyBuffer *dst,
                                                                  const struct CanvasExtent3d *copy_size);
 
-void canvas_native_webgpu_command_encoder_copy_texture_to_texture(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_copy_texture_to_texture(const struct CanvasGPUCommandEncoder *command_encoder,
                                                                   const struct CanvasImageCopyTexture *src,
                                                                   const struct CanvasImageCopyTexture *dst,
                                                                   const struct CanvasExtent3d *copy_size);
 
-struct CanvasGPUCommandBuffer *canvas_native_webgpu_command_encoder_finish(struct CanvasGPUCommandEncoder *command_encoder,
-                                                                           const char *label);
+const struct CanvasGPUCommandBuffer *canvas_native_webgpu_command_encoder_finish(const struct CanvasGPUCommandEncoder *command_encoder,
+                                                                                 const char *label);
 
-void canvas_native_webgpu_command_encoder_pop_debug_group(struct CanvasGPUCommandEncoder *command_encoder);
+void canvas_native_webgpu_command_encoder_pop_debug_group(const struct CanvasGPUCommandEncoder *command_encoder);
 
-void canvas_native_webgpu_command_encoder_push_debug_group(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_push_debug_group(const struct CanvasGPUCommandEncoder *command_encoder,
                                                            const char *label);
 
-void canvas_native_webgpu_command_encoder_resolve_query_set(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_resolve_query_set(const struct CanvasGPUCommandEncoder *command_encoder,
                                                             const struct CanvasGPUQuerySet *query_set,
                                                             uint32_t first_query,
                                                             uint32_t query_count,
                                                             struct CanvasGPUBuffer *dst,
                                                             uint64_t dst_offset);
 
-void canvas_native_webgpu_command_encoder_write_timestamp(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_write_timestamp(const struct CanvasGPUCommandEncoder *command_encoder,
                                                           const struct CanvasGPUQuerySet *query_set,
                                                           uint32_t query_index);
 
+void canvas_native_webgpu_compute_pass_reference(const struct CanvasGPUComputePassEncoder *compute_pass);
+
+void canvas_native_webgpu_compute_pass_release(const struct CanvasGPUComputePassEncoder *compute_pass);
+
+void canvas_native_webgpu_compute_pass_dispatch_workgroups(const struct CanvasGPUComputePassEncoder *compute_pass,
+                                                           uint32_t workgroup_count_x,
+                                                           uint32_t workgroup_count_y,
+                                                           uint32_t workgroup_count_z);
+
+void canvas_native_webgpu_compute_pass_dispatch_workgroups_indirect(const struct CanvasGPUComputePassEncoder *compute_pass,
+                                                                    const struct CanvasGPUBuffer *indirect_buffer,
+                                                                    uintptr_t indirect_offset);
+
+void canvas_native_webgpu_compute_pass_end(const struct CanvasGPUComputePassEncoder *compute_pass);
+
+void canvas_native_webgpu_compute_pass_insert_debug_marker(const struct CanvasGPUComputePassEncoder *compute_pass,
+                                                           const char *label);
+
+void canvas_native_webgpu_compute_pass_pop_debug_group(const struct CanvasGPUComputePassEncoder *compute_pass);
+
+void canvas_native_webgpu_compute_pass_push_debug_group(const struct CanvasGPUComputePassEncoder *compute_pass,
+                                                        const char *label);
+
+void canvas_native_webgpu_compute_pass_set_bind_group(const struct CanvasGPUComputePassEncoder *compute_pass,
+                                                      uint32_t index,
+                                                      const struct CanvasGPUBindGroup *bind_group,
+                                                      const uint32_t *dynamic_offsets,
+                                                      uintptr_t dynamic_offsets_size,
+                                                      uintptr_t dynamic_offsets_start,
+                                                      uintptr_t dynamic_offsets_length);
+
+void canvas_native_webgpu_compute_pass_set_pipeline(struct CanvasGPUComputePassEncoder *compute_pass,
+                                                    const struct CanvasGPUComputePipeline *pipeline);
+
 struct StringBuffer *canvas_native_webgpu_device_get_features(const struct CanvasGPUDevice *device);
 
 struct CanvasGPUSupportedLimits *canvas_native_webgpu_device_get_limits(const struct CanvasGPUDevice *device);
 
-struct CanvasGPUQueue *canvas_native_webgpu_device_get_queue(const struct CanvasGPUDevice *device);
+const struct CanvasGPUQueue *canvas_native_webgpu_device_get_queue(const struct CanvasGPUDevice *device);
 
 void canvas_native_webgpu_device_set_lost_callback(const struct CanvasGPUDevice *device,
                                                    void (*callback)(int32_t, char*, void*),
-                                                   void *callback_data);
+                                                   void *userdata);
 
 void canvas_native_webgpu_device_destroy(const struct CanvasGPUDevice *device);
 
-void canvas_native_webgpu_device_destroy_destory(struct CanvasGPUDevice *device);
+void canvas_native_webgpu_device_reference(const struct CanvasGPUDevice *device);
 
-struct CanvasGPUCommandEncoder *canvas_native_webgpu_device_create_command_encoder(const struct CanvasGPUDevice *device,
-                                                                                   const char *label);
+void canvas_native_webgpu_device_release(const struct CanvasGPUDevice *device);
 
-struct CanvasGPUShaderModule *canvas_native_webgpu_device_create_shader_module(const struct CanvasGPUDevice *device,
+const struct CanvasGPUBindGroupLayout *canvas_native_webgpu_device_create_bind_group_layout(const struct CanvasGPUDevice *device,
+                                                                                            const char *label,
+                                                                                            const struct CanvasBindGroupLayoutEntry *entries,
+                                                                                            uintptr_t size);
+
+const struct CanvasGPUBindGroup *canvas_native_webgpu_device_create_bind_group(const struct CanvasGPUDevice *device,
                                                                                const char *label,
-                                                                               const char *source);
+                                                                               const struct CanvasGPUBindGroupLayout *layout,
+                                                                               const struct CanvasBindGroupEntry *entries,
+                                                                               uintptr_t size);
+
+const struct CanvasGPUCommandEncoder *canvas_native_webgpu_device_create_command_encoder(const struct CanvasGPUDevice *device,
+                                                                                         const char *label);
+
+const struct CanvasGPUComputePipeline *canvas_native_webgpu_device_create_compute_pipeline(const struct CanvasGPUDevice *device,
+                                                                                           const char *label,
+                                                                                           struct CanvasGPUPipelineLayoutOrGPUAutoLayoutMode layout,
+                                                                                           const struct CanvasProgrammableStage *compute);
+
+void canvas_native_webgpu_device_create_compute_pipeline_async(const struct CanvasGPUDevice *device,
+                                                               const char *label,
+                                                               struct CanvasGPUPipelineLayoutOrGPUAutoLayoutMode layout,
+                                                               const struct CanvasProgrammableStage *compute,
+                                                               void (*callback)(const struct CanvasGPUComputePipeline*,
+                                                                                enum CanvasGPUErrorType,
+                                                                                char*,
+                                                                                void*),
+                                                               void *callback_data);
+
+const struct CanvasGPUPipelineLayout *canvas_native_webgpu_device_create_pipeline_layout(const struct CanvasGPUDevice *device,
+                                                                                         const char *label,
+                                                                                         const struct CanvasGPUBindGroupLayout *group_layouts,
+                                                                                         uintptr_t size);
+
+const struct CanvasGPUQuerySet *canvas_native_webgpu_device_create_query_set(const struct CanvasGPUDevice *device,
+                                                                             const char *label,
+                                                                             enum CanvasQueryType type_,
+                                                                             uint32_t count);
+
+const struct CanvasGPURenderBundleEncoder *canvas_native_webgpu_device_create_render_bundle_encoder(const struct CanvasGPUDevice *device,
+                                                                                                    const struct CanvasCreateRenderBundleEncoderDescriptor *descriptor);
+
+const struct CanvasGPUShaderModule *canvas_native_webgpu_device_create_shader_module(const struct CanvasGPUDevice *device,
+                                                                                     const char *label,
+                                                                                     const char *source);
 
-struct CanvasGPUBuffer *canvas_native_webgpu_device_create_buffer(const struct CanvasGPUDevice *device,
-                                                                  const char *label,
-                                                                  uint64_t size,
-                                                                  uint32_t usage,
-                                                                  bool mapped_at_creation,
-                                                                  char *error);
+const struct CanvasGPUBuffer *canvas_native_webgpu_device_create_buffer(const struct CanvasGPUDevice *device,
+                                                                        const char *label,
+                                                                        uint64_t size,
+                                                                        uint32_t usage,
+                                                                        bool mapped_at_creation);
 
 struct CanvasConstants *canvas_native_webgpu_constants_create(void);
 
@@ -4239,35 +4611,45 @@ void canvas_native_webgpu_constants_insert(struct CanvasConstants *constants,
 
 void canvas_native_webgpu_constants_destroy(struct CanvasConstants *constants);
 
-struct CanvasGPURenderPipeline *canvas_native_webgpu_device_create_render_pipeline(const struct CanvasGPUDevice *device,
-                                                                                   const struct CanvasCreateRenderPipelineDescriptor *descriptor);
+const struct CanvasGPURenderPipeline *canvas_native_webgpu_device_create_render_pipeline(const struct CanvasGPUDevice *device,
+                                                                                         const struct CanvasCreateRenderPipelineDescriptor *descriptor);
 
-struct CanvasGPUTexture *canvas_native_webgpu_device_create_texture(const struct CanvasGPUDevice *device,
-                                                                    const struct CanvasCreateTextureDescriptor *descriptor,
-                                                                    char *error);
+void canvas_native_webgpu_device_create_render_pipeline_async(const struct CanvasGPUDevice *device,
+                                                              const struct CanvasCreateRenderPipelineDescriptor *descriptor,
+                                                              void (*callback)(const struct CanvasGPURenderPipeline*,
+                                                                               enum CanvasGPUErrorType,
+                                                                               char*,
+                                                                               void*),
+                                                              void *callback_data);
 
-void canvas_native_webgpu_queue_copy_external_image_to_texture(struct CanvasGPUQueue *queue,
+const struct CanvasGPUTexture *canvas_native_webgpu_device_create_texture(const struct CanvasGPUDevice *device,
+                                                                          const struct CanvasCreateTextureDescriptor *descriptor);
+
+const struct CanvasGPUSampler *canvas_native_webgpu_device_create_sampler(const struct CanvasGPUDevice *device,
+                                                                          const struct CanvasCreateSamplerDescriptor *descriptor);
+
+void canvas_native_webgpu_queue_copy_external_image_to_texture(const struct CanvasGPUQueue *queue,
                                                                const struct CanvasImageCopyExternalImage *source,
                                                                const struct CanvasImageCopyTexture *destination,
                                                                const struct CanvasExtent3d *size);
 
-void canvas_native_webgpu_queue_on_submitted_work_done(struct CanvasGPUQueue *queue,
+void canvas_native_webgpu_queue_on_submitted_work_done(const struct CanvasGPUQueue *queue,
                                                        void (*callback)(char*, void*),
                                                        void *callback_data);
 
-void canvas_native_webgpu_queue_submit(struct CanvasGPUQueue *queue,
+void canvas_native_webgpu_queue_submit(const struct CanvasGPUQueue *queue,
                                        const struct CanvasGPUCommandBuffer *const *command_buffers,
                                        uintptr_t command_buffers_size);
 
-void canvas_native_webgpu_queue_write_buffer(struct CanvasGPUQueue *queue,
-                                             struct CanvasGPUBuffer *buffer,
+void canvas_native_webgpu_queue_write_buffer(const struct CanvasGPUQueue *queue,
+                                             const struct CanvasGPUBuffer *buffer,
                                              uint64_t buffer_offset,
                                              const uint8_t *data,
                                              uintptr_t data_size,
                                              uintptr_t data_offset,
                                              intptr_t size);
 
-void canvas_native_webgpu_queue_write_texture(struct CanvasGPUQueue *queue,
+void canvas_native_webgpu_queue_write_texture(const struct CanvasGPUQueue *queue,
                                               const struct CanvasImageCopyTexture *destination,
                                               const struct CanvasImageDataLayout *data_layout,
                                               const struct CanvasExtent3d *size,
@@ -4276,49 +4658,49 @@ void canvas_native_webgpu_queue_write_texture(struct CanvasGPUQueue *queue,
 
 struct CanvasGPUSupportedLimits *canvas_native_webgpu_create_limits(void);
 
-void canvas_native_webgpu_limits_destroy(struct CanvasGPUSupportedLimits *limits);
+void canvas_native_webgpu_limits_release(struct CanvasGPUSupportedLimits *limits);
 
-void canvas_native_webgpu_render_pass_begin_occlusion_query(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_begin_occlusion_query(const struct CanvasGPURenderPassEncoder *render_pass,
                                                             uint32_t query_index);
 
-void canvas_native_webgpu_render_pass_encoder_draw(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_encoder_draw(const struct CanvasGPURenderPassEncoder *render_pass,
                                                    uint32_t vertex_count,
                                                    uint32_t instance_count,
                                                    uint32_t first_vertex,
                                                    uint32_t first_instance);
 
-void canvas_native_webgpu_render_pass_draw_indexed(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_draw_indexed(const struct CanvasGPURenderPassEncoder *render_pass,
                                                    uint32_t index_count,
                                                    uint32_t instance_count,
                                                    uint32_t first_index,
                                                    int32_t base_vertex,
                                                    uint32_t first_instance);
 
-void canvas_native_webgpu_render_pass_draw_indexed_indirect(struct CanvasGPURenderPass *render_pass,
-                                                            struct CanvasGPUBuffer *indirect_buffer,
+void canvas_native_webgpu_render_pass_draw_indexed_indirect(const struct CanvasGPURenderPassEncoder *render_pass,
+                                                            const struct CanvasGPUBuffer *indirect_buffer,
                                                             uint64_t indirect_offset);
 
-void canvas_native_webgpu_render_pass_draw_indirect(struct CanvasGPURenderPass *render_pass,
-                                                    struct CanvasGPUBuffer *indirect_buffer,
+void canvas_native_webgpu_render_pass_draw_indirect(const struct CanvasGPURenderPassEncoder *render_pass,
+                                                    const struct CanvasGPUBuffer *indirect_buffer,
                                                     uint64_t indirect_offset);
 
-void canvas_native_webgpu_render_pass_end(struct CanvasGPURenderPass *render_pass);
+void canvas_native_webgpu_render_pass_end(const struct CanvasGPURenderPassEncoder *render_pass);
 
-void canvas_native_webgpu_render_pass_end_occlusion_query(struct CanvasGPURenderPass *render_pass);
+void canvas_native_webgpu_render_pass_end_occlusion_query(const struct CanvasGPURenderPassEncoder *render_pass);
 
-void canvas_native_webgpu_render_pass_execute_bundles(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_execute_bundles(const struct CanvasGPURenderPassEncoder *render_pass,
                                                       const struct CanvasGPURenderBundle *bundles,
                                                       uintptr_t bundles_size);
 
-void canvas_native_webgpu_render_pass_insert_debug_marker(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_insert_debug_marker(const struct CanvasGPURenderPassEncoder *render_pass,
                                                           const char *label);
 
-void canvas_native_webgpu_render_pass_pop_debug_group(struct CanvasGPURenderPass *render_pass);
+void canvas_native_webgpu_render_pass_pop_debug_group(const struct CanvasGPURenderPassEncoder *render_pass);
 
-void canvas_native_webgpu_render_pass_push_debug_group(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_push_debug_group(const struct CanvasGPURenderPassEncoder *render_pass,
                                                        const char *label);
 
-void canvas_native_webgpu_render_pass_set_bind_group(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_bind_group(const struct CanvasGPURenderPassEncoder *render_pass,
                                                      uint32_t index,
                                                      const struct CanvasGPUBindGroup *bind_group,
                                                      const uint32_t *dynamic_offsets,
@@ -4326,34 +4708,34 @@ void canvas_native_webgpu_render_pass_set_bind_group(struct CanvasGPURenderPass
                                                      uintptr_t dynamic_offsets_start,
                                                      uintptr_t dynamic_offsets_length);
 
-void canvas_native_webgpu_render_pass_set_blend_constant(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_blend_constant(const struct CanvasGPURenderPassEncoder *render_pass,
                                                          const struct CanvasColor *color);
 
-void canvas_native_webgpu_render_pass_set_index_buffer(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_index_buffer(const struct CanvasGPURenderPassEncoder *render_pass,
                                                        const struct CanvasGPUBuffer *buffer,
                                                        enum CanvasIndexFormat index_format,
                                                        int64_t offset,
                                                        int64_t size);
 
-void canvas_native_webgpu_render_pass_set_pipeline(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_pipeline(const struct CanvasGPURenderPassEncoder *render_pass,
                                                    const struct CanvasGPURenderPipeline *pipeline);
 
-void canvas_native_webgpu_render_pass_set_scissor_rect(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_scissor_rect(const struct CanvasGPURenderPassEncoder *render_pass,
                                                        uint32_t x,
                                                        uint32_t y,
                                                        uint32_t width,
                                                        uint32_t height);
 
-void canvas_native_webgpu_render_pass_set_stencil_reference(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_stencil_reference(const struct CanvasGPURenderPassEncoder *render_pass,
                                                             uint32_t reference);
 
-void canvas_native_webgpu_render_pass_set_vertex_buffer(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_vertex_buffer(const struct CanvasGPURenderPassEncoder *render_pass,
                                                         uint32_t slot,
-                                                        struct CanvasGPUBuffer *buffer,
+                                                        const struct CanvasGPUBuffer *buffer,
                                                         int64_t offset,
                                                         int64_t size);
 
-void canvas_native_webgpu_render_pass_set_viewport(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_viewport(const struct CanvasGPURenderPassEncoder *render_pass,
                                                    float x,
                                                    float y,
                                                    float width,
@@ -4361,73 +4743,105 @@ void canvas_native_webgpu_render_pass_set_viewport(struct CanvasGPURenderPass *r
                                                    float depth_min,
                                                    float depth_max);
 
+void canvas_native_webgpu_render_pass_reference(const struct CanvasGPURenderPassEncoder *render_pass);
+
+void canvas_native_webgpu_render_pass_release(const struct CanvasGPURenderPassEncoder *render_pass);
+
 #if defined(TARGET_OS_ANDROID)
-struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create(struct CanvasWebGPUInstance *instance,
-                                                                   void *window,
-                                                                   uint32_t width,
-                                                                   uint32_t height);
+const struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create(struct CanvasWebGPUInstance *instance,
+                                                                         void *window,
+                                                                         uint32_t width,
+                                                                         uint32_t height);
 #endif
 
 #if (defined(TARGET_OS_IOS) || defined(TARGET_OS_MACOS))
-struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create(struct CanvasWebGPUInstance *instance,
-                                                                   void *view,
-                                                                   uint32_t width,
-                                                                   uint32_t height);
+const struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create(const struct CanvasWebGPUInstance *instance,
+                                                                         void *view,
+                                                                         uint32_t width,
+                                                                         uint32_t height);
 #endif
 
 #if defined(TARGET_OS_IOS)
-struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create_uiview(struct CanvasWebGPUInstance *instance,
-                                                                          void *view,
-                                                                          uint32_t width,
-                                                                          uint32_t height);
+const struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create_uiview(const struct CanvasWebGPUInstance *instance,
+                                                                                void *view,
+                                                                                uint32_t width,
+                                                                                uint32_t height);
 #endif
 
 #if defined(TARGET_OS_MACOS)
-struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create_nsview(struct CanvasWebGPUInstance *instance,
-                                                                          void *view,
-                                                                          uint32_t width,
-                                                                          uint32_t height);
+const struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create_nsview(const struct CanvasWebGPUInstance *instance,
+                                                                                void *view,
+                                                                                uint32_t width,
+                                                                                uint32_t height);
 #endif
 
-void canvas_native_webgpu_context_configure(struct CanvasGPUCanvasContext *context,
-                                            struct CanvasGPUDevice *device,
+void canvas_native_webgpu_context_configure(const struct CanvasGPUCanvasContext *context,
+                                            const struct CanvasGPUDevice *device,
                                             const struct CanvasGPUSurfaceConfiguration *config);
 
-void canvas_native_webgpu_context_unconfigure(struct CanvasGPUCanvasContext *context,
+void canvas_native_webgpu_context_unconfigure(const struct CanvasGPUCanvasContext *context,
                                               struct CanvasGPUDevice *device,
                                               const struct CanvasGPUSurfaceConfiguration *config);
 
-struct CanvasGPUTexture *canvas_native_webgpu_context_get_current_texture(struct CanvasGPUCanvasContext *context);
+const struct CanvasGPUTexture *canvas_native_webgpu_context_get_current_texture(const struct CanvasGPUCanvasContext *context);
+
+void canvas_native_webgpu_context_present_surface(const struct CanvasGPUCanvasContext *context);
+
+void canvas_native_webgpu_context_get_capabilities(const struct CanvasGPUCanvasContext *context,
+                                                   const struct CanvasGPUAdapter *adapter);
 
 char *canvas_native_webgpu_enum_gpu_texture_to_string(struct CanvasGPUTextureFormat value);
 
 struct CanvasOptionalGPUTextureFormat canvas_native_webgpu_string_to_gpu_texture_enum(const char *format);
 
-struct CanvasGPUTextureView *canvas_native_webgpu_texture_create_texture_view(struct CanvasGPUTexture *texture,
-                                                                              const struct CanvasCreateTextureViewDescriptor *descriptor);
+void canvas_native_webgpu_texture_reference(const struct CanvasGPUTexture *texture);
+
+void canvas_native_webgpu_texture_release(const struct CanvasGPUTexture *texture);
+
+const struct CanvasGPUTextureView *canvas_native_webgpu_texture_create_texture_view(const struct CanvasGPUTexture *texture,
+                                                                                    const struct CanvasCreateTextureViewDescriptor *descriptor);
+
+uint32_t canvas_native_webgpu_texture_get_depth_or_array_layers(const struct CanvasGPUTexture *texture);
+
+uint32_t canvas_native_webgpu_texture_get_width(const struct CanvasGPUTexture *texture);
+
+uint32_t canvas_native_webgpu_texture_get_height(const struct CanvasGPUTexture *texture);
+
+enum CanvasTextureDimension canvas_native_webgpu_texture_get_dimension(const struct CanvasGPUTexture *texture);
+
+struct CanvasGPUTextureFormat canvas_native_webgpu_texture_get_format(const struct CanvasGPUTexture *texture);
+
+uint32_t canvas_native_webgpu_texture_get_usage(const struct CanvasGPUTexture *texture);
+
+char *canvas_native_webgpu_texture_get_label(const struct CanvasGPUTexture *_texture);
+
+uint32_t canvas_native_webgpu_texture_get_mip_level_count(const struct CanvasGPUTexture *texture);
+
+uint32_t canvas_native_webgpu_texture_get_sample_count(const struct CanvasGPUTexture *texture);
 
-uint32_t canvas_native_webgpu_texture_get_depth_or_array_layers(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_texture_destroy(const struct CanvasGPUTexture *texture);
 
-uint32_t canvas_native_webgpu_texture_get_width(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_texture_view_reference(const struct CanvasGPUTextureView *texture_view);
 
-uint32_t canvas_native_webgpu_texture_get_height(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_texture_view_release(const struct CanvasGPUTextureView *texture_view);
 
-enum CanvasTextureDimension canvas_native_webgpu_texture_get_dimension(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_bind_group_reference(const struct CanvasGPUBindGroup *bind_group);
 
-struct CanvasGPUTextureFormat canvas_native_webgpu_texture_get_format(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_bind_group_release(const struct CanvasGPUBindGroup *bind_group);
 
-uint32_t canvas_native_webgpu_texture_get_usage(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_bind_group_layout_reference(const struct CanvasGPUBindGroupLayout *bind_group_layout);
 
-char *canvas_native_webgpu_texture_get_label(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_bind_group_layout_release(const struct CanvasGPUBindGroupLayout *bind_group_layout);
 
-uint32_t canvas_native_webgpu_texture_get_mip_level_count(struct CanvasGPUTexture *texture);
+const struct CanvasGPUBindGroupLayout *canvas_native_webgpu_render_pipeline_get_bind_group_layout(const struct CanvasGPURenderPipeline *pipeline,
+                                                                                                  uint32_t index);
 
-uint32_t canvas_native_webgpu_texture_get_sample_count(struct CanvasGPUTexture *texture);
+enum CanvasGPUErrorType canvas_native_webgpu_error_get_type(const struct CanvasGPUError *error);
 
-char *canvas_native_webgpu_texture_destroy(struct CanvasGPUTexture *texture);
+char *canvas_native_webgpu_error_get_message(const struct CanvasGPUError *error);
 
-struct CanvasGPUBindGroupLayout *canvas_native_webgpu_render_pipeline_get_bind_group_layout(const struct CanvasGPURenderPipeline *pipeline,
-                                                                                            uint32_t index);
+const struct CanvasGPUBindGroupLayout *canvas_native_webgpu_compute_pipeline_get_bind_group_layout(const struct CanvasGPUComputePipeline *pipeline,
+                                                                                                   uint32_t index);
 
 const uint8_t *canvas_native_u8_buffer_get_bytes(const struct U8Buffer *buffer);
 
diff --git a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative
index 97a24028f..ec119f46d 100644
Binary files a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative and b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative differ
diff --git a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/Relocations/aarch64/CanvasNative.yml b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/Relocations/aarch64/CanvasNative.yml
index 04564eeaf..43812958c 100644
--- a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/Relocations/aarch64/CanvasNative.yml
+++ b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/Relocations/aarch64/CanvasNative.yml
@@ -2,606 +2,606 @@
 triple:          'arm64-apple-darwin'
 binary-path:     '/Users/triniwiz/Documents/GitHub/canvas/packages/canvas/src-native/canvas-ios/dist/Release-iphoneos/CanvasNative.framework/CanvasNative'
 relocations:
-  - { offsetInCU: 0x34, offset: 0x7718F, size: 0x8, addend: 0x0, symName: _CanvasNativeVersionString, symObjAddr: 0x0, symBinAddr: 0x8EC000, symSize: 0x0 }
-  - { offsetInCU: 0x69, offset: 0x771C4, size: 0x8, addend: 0x0, symName: _CanvasNativeVersionNumber, symObjAddr: 0x38, symBinAddr: 0x8EC038, symSize: 0x0 }
-  - { offsetInCU: 0x3F, offset: 0x77219, size: 0x8, addend: 0x0, symName: ___swift_memcpy16_8, symObjAddr: 0x28, symBinAddr: 0x8028, symSize: 0xC }
-  - { offsetInCU: 0x53, offset: 0x7722D, size: 0x8, addend: 0x0, symName: ___swift_noop_void_return, symObjAddr: 0x34, symBinAddr: 0x8034, symSize: 0x4 }
-  - { offsetInCU: 0x67, offset: 0x77241, size: 0x8, addend: 0x0, symName: '_$sSo6CGSizeVwet', symObjAddr: 0x38, symBinAddr: 0x8038, symSize: 0x20 }
-  - { offsetInCU: 0x7B, offset: 0x77255, size: 0x8, addend: 0x0, symName: '_$sSo6CGSizeVwst', symObjAddr: 0x58, symBinAddr: 0x8058, symSize: 0x28 }
-  - { offsetInCU: 0x8F, offset: 0x77269, size: 0x8, addend: 0x0, symName: '_$sSo6CGRectVwCP', symObjAddr: 0x94, symBinAddr: 0x8094, symSize: 0x30 }
-  - { offsetInCU: 0xA3, offset: 0x7727D, size: 0x8, addend: 0x0, symName: ___swift_memcpy32_8, symObjAddr: 0xC4, symBinAddr: 0x80C4, symSize: 0xC }
-  - { offsetInCU: 0xB7, offset: 0x77291, size: 0x8, addend: 0x0, symName: '_$sSo6CGRectVwet', symObjAddr: 0xD0, symBinAddr: 0x80D0, symSize: 0x20 }
-  - { offsetInCU: 0xCB, offset: 0x772A5, size: 0x8, addend: 0x0, symName: '_$sSo6CGRectVwst', symObjAddr: 0xF0, symBinAddr: 0x80F0, symSize: 0x2C }
-  - { offsetInCU: 0x4F, offset: 0x7748E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC11_WriteQueue33_05178D28796EA758448493B56DC45144LLSo011NSOperationE0CSgvpZ', symObjAddr: 0x2AE8, symBinAddr: 0x10D39A0, symSize: 0x0 }
-  - { offsetInCU: 0x69, offset: 0x774A8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10_ReadQueue33_05178D28796EA758448493B56DC45144LLSo011NSOperationE0CSgvpZ', symObjAddr: 0x2AF0, symBinAddr: 0x10D39A8, symSize: 0x0 }
-  - { offsetInCU: 0x9D, offset: 0x774DC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC19getBytesFromUIImageySo13NSMutableDataCSo0G0CFZTo', symObjAddr: 0x4, symBinAddr: 0x8194, symSize: 0x38 }
-  - { offsetInCU: 0xF3, offset: 0x77532, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13createPatternys5Int64VAF_So7UIImageCSStFZTo', symObjAddr: 0x40, symBinAddr: 0x81D0, symSize: 0x70 }
-  - { offsetInCU: 0x144, offset: 0x77583, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC25loadImageAssetWithContextySbs5Int64V_So7UIImageCtFZTo', symObjAddr: 0xB4, symBinAddr: 0x8244, symSize: 0x44 }
-  - { offsetInCU: 0x19F, offset: 0x775DE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dyys5Int64V_So7UIImageCS2ftFZTo', symObjAddr: 0xFC, symBinAddr: 0x828C, symSize: 0x50 }
-  - { offsetInCU: 0x204, offset: 0x77643, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dy2dw2dhys5Int64V_So7UIImageCS4ftFZTo', symObjAddr: 0x150, symBinAddr: 0x82E0, symSize: 0x68 }
-  - { offsetInCU: 0x27D, offset: 0x776BC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2sx2sy2sw2sh2dx2dy2dw2dhys5Int64V_So7UIImageCS8ftFZTo', symObjAddr: 0x1BC, symBinAddr: 0x834C, symSize: 0x98 }
-  - { offsetInCU: 0x2DA, offset: 0x77719, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23initWebGPUWithViewLayerys5Int64VAF_AFs6UInt32VAHtFZTo', symObjAddr: 0x258, symBinAddr: 0x83E8, symSize: 0x14 }
-  - { offsetInCU: 0x35C, offset: 0x7779B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC18initWebGPUWithViewys5Int64VAF_AFs6UInt32VAHtFZTo', symObjAddr: 0x270, symBinAddr: 0x8400, symSize: 0x14 }
-  - { offsetInCU: 0x40B, offset: 0x7784A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14initGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbtFZTo', symObjAddr: 0x2C8, symBinAddr: 0x8458, symSize: 0x50 }
-  - { offsetInCU: 0x4DC, offset: 0x7791B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC20initSharedGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbAFtFZTo', symObjAddr: 0x364, symBinAddr: 0x84F4, symSize: 0x58 }
-  - { offsetInCU: 0x5B6, offset: 0x779F5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC24initGLWithWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbtFZTo', symObjAddr: 0x404, symBinAddr: 0x8594, symSize: 0x58 }
-  - { offsetInCU: 0x695, offset: 0x77AD4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC26initSharedGLWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbAFtFZTo', symObjAddr: 0x4AC, symBinAddr: 0x863C, symSize: 0x60 }
-  - { offsetInCU: 0x741, offset: 0x77B80, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15resize2DContextyys5Int64V_S2ftFZTo', symObjAddr: 0x510, symBinAddr: 0x86A0, symSize: 0x8 }
-  - { offsetInCU: 0x7AA, offset: 0x77BE9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14flush2DContextyys5Int64VFZTo', symObjAddr: 0x51C, symBinAddr: 0x86AC, symSize: 0x8 }
-  - { offsetInCU: 0x801, offset: 0x77C40, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC7flushGLySbs5Int64VFZTo', symObjAddr: 0x538, symBinAddr: 0x86C8, symSize: 0x8 }
-  - { offsetInCU: 0x858, offset: 0x77C97, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9releaseGLyys5Int64VFZTo', symObjAddr: 0x544, symBinAddr: 0x86D4, symSize: 0x8 }
-  - { offsetInCU: 0x8AF, offset: 0x77CEE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC12getGLPointerys5Int64VAFFZTo', symObjAddr: 0x550, symBinAddr: 0x86E0, symSize: 0x8 }
-  - { offsetInCU: 0x906, offset: 0x77D45, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC16releaseGLPointeryys5Int64VFZTo', symObjAddr: 0x55C, symBinAddr: 0x86EC, symSize: 0x8 }
-  - { offsetInCU: 0x985, offset: 0x77DC4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15create2DContextys5Int64VAF_s5Int32VAHSbSfA2HSfAHtFZTo', symObjAddr: 0x56C, symBinAddr: 0x86FC, symSize: 0x24 }
-  - { offsetInCU: 0xA36, offset: 0x77E75, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23updateGLSurfaceWithViewyys5Int64V_s5Int32VAhFtFZTo', symObjAddr: 0x594, symBinAddr: 0x8724, symSize: 0x14 }
-  - { offsetInCU: 0xAA9, offset: 0x77EE8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC6test2Dyys5Int64VFZTo', symObjAddr: 0x5AC, symBinAddr: 0x873C, symSize: 0x8 }
-  - { offsetInCU: 0xB00, offset: 0x77F3F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13testToDataURLySSs5Int64VFZTo', symObjAddr: 0x60C, symBinAddr: 0x879C, symSize: 0x74 }
-  - { offsetInCU: 0xB8B, offset: 0x77FCA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZTo', symObjAddr: 0x814, symBinAddr: 0x89A4, symSize: 0xA0 }
-  - { offsetInCU: 0xBDC, offset: 0x7801B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZTo', symObjAddr: 0xB1C, symBinAddr: 0x8CAC, symSize: 0x98 }
-  - { offsetInCU: 0xC2D, offset: 0x7806C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZTo', symObjAddr: 0xE70, symBinAddr: 0x9000, symSize: 0x98 }
-  - { offsetInCU: 0xC89, offset: 0x780C8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZTo', symObjAddr: 0x1298, symBinAddr: 0x9428, symSize: 0xD8 }
-  - { offsetInCU: 0xCD1, offset: 0x78110, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC32getPixelsPerInchForCurrentDeviceSSyFZTo', symObjAddr: 0x1374, symBinAddr: 0x9504, symSize: 0x34 }
-  - { offsetInCU: 0xD31, offset: 0x78170, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCACycfcTo', symObjAddr: 0x13F8, symBinAddr: 0x9588, symSize: 0x3C }
-  - { offsetInCU: 0xD82, offset: 0x781C1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC19getBytesFromUIImageySo13NSMutableDataCSo0G0CFZTf4nd_n', symObjAddr: 0x1468, symBinAddr: 0x95F8, symSize: 0x2AC }
-  - { offsetInCU: 0xFB6, offset: 0x783F5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13createPatternys5Int64VAF_So7UIImageCSStFZTf4nnnd_n', symObjAddr: 0x1714, symBinAddr: 0x98A4, symSize: 0x264 }
-  - { offsetInCU: 0x11B0, offset: 0x785EF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC25loadImageAssetWithContextySbs5Int64V_So7UIImageCtFZTf4nnd_n', symObjAddr: 0x1978, symBinAddr: 0x9B08, symSize: 0xEC }
-  - { offsetInCU: 0x12AD, offset: 0x786EC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dyys5Int64V_So7UIImageCS2ftFZTf4nnnnd_n', symObjAddr: 0x1A64, symBinAddr: 0x9BF4, symSize: 0x1B4 }
-  - { offsetInCU: 0x1422, offset: 0x78861, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dy2dw2dhys5Int64V_So7UIImageCS4ftFZTf4nnnnnnd_n', symObjAddr: 0x1C18, symBinAddr: 0x9DA8, symSize: 0x1CC }
-  - { offsetInCU: 0x15B7, offset: 0x789F6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2sx2sy2sw2sh2dx2dy2dw2dhys5Int64V_So7UIImageCS8ftFZTf4nnnnnnnnnnd_n', symObjAddr: 0x1DE4, symBinAddr: 0x9F74, symSize: 0x1E0 }
-  - { offsetInCU: 0x17A3, offset: 0x78BE2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZTf4nnnd_n', symObjAddr: 0x1FC4, symBinAddr: 0xA154, symSize: 0x1B4 }
-  - { offsetInCU: 0x186D, offset: 0x78CAC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZTf4nnnnd_n', symObjAddr: 0x231C, symBinAddr: 0xA4AC, symSize: 0x1D4 }
-  - { offsetInCU: 0x194E, offset: 0x78D8D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC32getPixelsPerInchForCurrentDeviceSSyFZTf4d_n', symObjAddr: 0x24F0, symBinAddr: 0xA680, symSize: 0x114 }
-  - { offsetInCU: 0x19F9, offset: 0x78E38, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgACIeyByy_SSSgADIeggg_TR', symObjAddr: 0x8B4, symBinAddr: 0x8A44, symSize: 0x78 }
-  - { offsetInCU: 0x1A11, offset: 0x78E50, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgSo6NSDataCSgIeyByy_SSSgAFIeggg_TR', symObjAddr: 0xBB4, symBinAddr: 0x8D44, symSize: 0x54 }
-  - { offsetInCU: 0x1A7E, offset: 0x78EBD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCfETo', symObjAddr: 0x1464, symBinAddr: 0x95F4, symSize: 0x4 }
-  - { offsetInCU: 0x1B09, offset: 0x78F48, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCMa', symObjAddr: 0x2604, symBinAddr: 0xA794, symSize: 0x20 }
-  - { offsetInCU: 0x1B1D, offset: 0x78F5C, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgACIeyByy_SSSgADIeggg_TRTA', symObjAddr: 0x2648, symBinAddr: 0xA7D8, symSize: 0x8 }
-  - { offsetInCU: 0x1B3C, offset: 0x78F7B, size: 0x8, addend: 0x0, symName: '_$sSo7NSErrorCSg10ObjectiveC8ObjCBoolVIeyByy_ACSbIeggy_TRTA', symObjAddr: 0x2650, symBinAddr: 0xA7E0, symSize: 0x18 }
-  - { offsetInCU: 0x1B65, offset: 0x78FA4, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgSo6NSDataCSgIeyByy_SSSgAFIeggg_TRTA', symObjAddr: 0x2668, symBinAddr: 0xA7F8, symSize: 0x8 }
-  - { offsetInCU: 0x1B79, offset: 0x78FB8, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCMa', symObjAddr: 0x2670, symBinAddr: 0xA800, symSize: 0x3C }
-  - { offsetInCU: 0x1B8D, offset: 0x78FCC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZyyYbcfU_TA', symObjAddr: 0x26F0, symBinAddr: 0xA880, symSize: 0x34 }
-  - { offsetInCU: 0x1BA1, offset: 0x78FE0, size: 0x8, addend: 0x0, symName: _block_copy_helper, symObjAddr: 0x2724, symBinAddr: 0xA8B4, symSize: 0x10 }
-  - { offsetInCU: 0x1BB5, offset: 0x78FF4, size: 0x8, addend: 0x0, symName: _block_destroy_helper, symObjAddr: 0x2734, symBinAddr: 0xA8C4, symSize: 0x8 }
-  - { offsetInCU: 0x1BC9, offset: 0x79008, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZyyYbcfU_yyYbcfU0_TA', symObjAddr: 0x2760, symBinAddr: 0xA8F0, symSize: 0x40 }
-  - { offsetInCU: 0x1BFD, offset: 0x7903C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZyyYbcfU_yyYbcfU0_TA', symObjAddr: 0x27E4, symBinAddr: 0xA974, symSize: 0x40 }
-  - { offsetInCU: 0x1C3B, offset: 0x7907A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZyyYbcfU_yyYbcfU_TA', symObjAddr: 0x2824, symBinAddr: 0xA9B4, symSize: 0x28 }
-  - { offsetInCU: 0x1C6F, offset: 0x790AE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZyyYbcfU_yyYbcfU_TA', symObjAddr: 0x28A4, symBinAddr: 0xAA34, symSize: 0x3C }
-  - { offsetInCU: 0x1CA3, offset: 0x790E2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZyyYbcfU_yyYbcfU0_TA', symObjAddr: 0x290C, symBinAddr: 0xAA9C, symSize: 0x30 }
-  - { offsetInCU: 0x1CDF, offset: 0x7911E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZyyYbcfU_TA', symObjAddr: 0x2978, symBinAddr: 0xAB08, symSize: 0x10 }
-  - { offsetInCU: 0x1CF3, offset: 0x79132, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZyyYbcfU_yyYbcfU_TA', symObjAddr: 0x2988, symBinAddr: 0xAB18, symSize: 0x40 }
-  - { offsetInCU: 0x21C0, offset: 0x795FF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC19getBytesFromUIImageySo13NSMutableDataCSo0G0CFZ', symObjAddr: 0x0, symBinAddr: 0x8190, symSize: 0x4 }
-  - { offsetInCU: 0x21DB, offset: 0x7961A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x3C, symBinAddr: 0x81CC, symSize: 0x4 }
-  - { offsetInCU: 0x21F6, offset: 0x79635, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC25loadImageAssetWithContextySbs5Int64V_So7UIImageCtFZ', symObjAddr: 0xB0, symBinAddr: 0x8240, symSize: 0x4 }
-  - { offsetInCU: 0x2217, offset: 0x79656, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dyys5Int64V_So7UIImageCS2ftFZ', symObjAddr: 0xF8, symBinAddr: 0x8288, symSize: 0x4 }
-  - { offsetInCU: 0x2232, offset: 0x79671, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dy2dw2dhys5Int64V_So7UIImageCS4ftFZ', symObjAddr: 0x14C, symBinAddr: 0x82DC, symSize: 0x4 }
-  - { offsetInCU: 0x224D, offset: 0x7968C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2sx2sy2sw2sh2dx2dy2dw2dhys5Int64V_So7UIImageCS8ftFZ', symObjAddr: 0x1B8, symBinAddr: 0x8348, symSize: 0x4 }
-  - { offsetInCU: 0x2268, offset: 0x796A7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23initWebGPUWithViewLayerys5Int64VAF_AFs6UInt32VAHtFZ', symObjAddr: 0x254, symBinAddr: 0x83E4, symSize: 0x4 }
-  - { offsetInCU: 0x22F6, offset: 0x79735, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC18initWebGPUWithViewys5Int64VAF_AFs6UInt32VAHtFZ', symObjAddr: 0x26C, symBinAddr: 0x83FC, symSize: 0x4 }
-  - { offsetInCU: 0x2375, offset: 0x797B4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14initGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbtFZ', symObjAddr: 0x284, symBinAddr: 0x8414, symSize: 0x44 }
-  - { offsetInCU: 0x24B3, offset: 0x798F2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC20initSharedGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbAFtFZ', symObjAddr: 0x318, symBinAddr: 0x84A8, symSize: 0x4C }
-  - { offsetInCU: 0x25FC, offset: 0x79A3B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC24initGLWithWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbtFZ', symObjAddr: 0x3BC, symBinAddr: 0x854C, symSize: 0x48 }
-  - { offsetInCU: 0x2744, offset: 0x79B83, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC26initSharedGLWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbAFtFZ', symObjAddr: 0x45C, symBinAddr: 0x85EC, symSize: 0x50 }
-  - { offsetInCU: 0x28A1, offset: 0x79CE0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15resize2DContextyys5Int64V_S2ftFZ', symObjAddr: 0x50C, symBinAddr: 0x869C, symSize: 0x4 }
-  - { offsetInCU: 0x2913, offset: 0x79D52, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14flush2DContextyys5Int64VFZ', symObjAddr: 0x518, symBinAddr: 0x86A8, symSize: 0x4 }
-  - { offsetInCU: 0x2956, offset: 0x79D95, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC7flushGLySbs5Int64VFZ', symObjAddr: 0x524, symBinAddr: 0x86B4, symSize: 0x14 }
-  - { offsetInCU: 0x299B, offset: 0x79DDA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9releaseGLyys5Int64VFZ', symObjAddr: 0x540, symBinAddr: 0x86D0, symSize: 0x4 }
-  - { offsetInCU: 0x29DE, offset: 0x79E1D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC12getGLPointerys5Int64VAFFZ', symObjAddr: 0x54C, symBinAddr: 0x86DC, symSize: 0x4 }
-  - { offsetInCU: 0x2A21, offset: 0x79E60, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC16releaseGLPointeryys5Int64VFZ', symObjAddr: 0x558, symBinAddr: 0x86E8, symSize: 0x4 }
-  - { offsetInCU: 0x2A64, offset: 0x79EA3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15create2DContextys5Int64VAF_s5Int32VAHSbSfA2HSfAHtFZ', symObjAddr: 0x564, symBinAddr: 0x86F4, symSize: 0x8 }
-  - { offsetInCU: 0x2B4B, offset: 0x79F8A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23updateGLSurfaceWithViewyys5Int64V_s5Int32VAhFtFZ', symObjAddr: 0x590, symBinAddr: 0x8720, symSize: 0x4 }
-  - { offsetInCU: 0x2BCA, offset: 0x7A009, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC6test2Dyys5Int64VFZ', symObjAddr: 0x5A8, symBinAddr: 0x8738, symSize: 0x4 }
-  - { offsetInCU: 0x2C0D, offset: 0x7A04C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13testToDataURLySSs5Int64VFZ', symObjAddr: 0x5B4, symBinAddr: 0x8744, symSize: 0x58 }
-  - { offsetInCU: 0x2CCE, offset: 0x7A10D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZ', symObjAddr: 0x680, symBinAddr: 0x8810, symSize: 0x4 }
-  - { offsetInCU: 0x2CE2, offset: 0x7A121, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZyyYbcfU_', symObjAddr: 0x684, symBinAddr: 0x8814, symSize: 0x190 }
-  - { offsetInCU: 0x2D82, offset: 0x7A1C1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZ', symObjAddr: 0x92C, symBinAddr: 0x8ABC, symSize: 0x2C }
-  - { offsetInCU: 0x2D96, offset: 0x7A1D5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZyyYbcfU_', symObjAddr: 0x958, symBinAddr: 0x8AE8, symSize: 0x1C4 }
-  - { offsetInCU: 0x2E80, offset: 0x7A2BF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZ', symObjAddr: 0xC08, symBinAddr: 0x8D98, symSize: 0x2C }
-  - { offsetInCU: 0x2E94, offset: 0x7A2D3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZyyYbcfU_', symObjAddr: 0xC34, symBinAddr: 0x8DC4, symSize: 0x23C }
-  - { offsetInCU: 0x2F48, offset: 0x7A387, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZ', symObjAddr: 0xF08, symBinAddr: 0x9098, symSize: 0x4 }
-  - { offsetInCU: 0x2F5C, offset: 0x7A39B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZyyYbcfU_', symObjAddr: 0xF0C, symBinAddr: 0x909C, symSize: 0x38C }
-  - { offsetInCU: 0x31F3, offset: 0x7A632, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC32getPixelsPerInchForCurrentDeviceSSyFZ', symObjAddr: 0x1370, symBinAddr: 0x9500, symSize: 0x4 }
-  - { offsetInCU: 0x320E, offset: 0x7A64D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCACycfC', symObjAddr: 0x13A8, symBinAddr: 0x9538, symSize: 0x20 }
-  - { offsetInCU: 0x3222, offset: 0x7A661, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCACycfc', symObjAddr: 0x13C8, symBinAddr: 0x9558, symSize: 0x30 }
-  - { offsetInCU: 0x3258, offset: 0x7A697, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCfD', symObjAddr: 0x1434, symBinAddr: 0x95C4, symSize: 0x30 }
-  - { offsetInCU: 0x4F, offset: 0x7A8CF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19shared_context_view33_508084857CA7D194CA72FEB80DD78002LLSo7GLKViewCvpZ', symObjAddr: 0x55E0, symBinAddr: 0x10D39E0, symSize: 0x0 }
-  - { offsetInCU: 0x69, offset: 0x7A8E9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15_shared_context33_508084857CA7D194CA72FEB80DD78002LLs5Int64VvpZ', symObjAddr: 0x55E8, symBinAddr: 0x10D39E8, symSize: 0x0 }
-  - { offsetInCU: 0x83, offset: 0x7A903, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5storeSo19NSMutableDictionaryCvpZ', symObjAddr: 0x55F0, symBinAddr: 0x10D39F0, symSize: 0x0 }
-  - { offsetInCU: 0x9D, offset: 0x7A91D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5views33_508084857CA7D194CA72FEB80DD78002LLSo10NSMapTableCySo8NSStringCACGvpZ', symObjAddr: 0x55F8, symBinAddr: 0x10D39F8, symSize: 0x0 }
-  - { offsetInCU: 0xAB, offset: 0x7A92B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19shared_context_view33_508084857CA7D194CA72FEB80DD78002LL_WZ', symObjAddr: 0x0, symBinAddr: 0xAC40, symSize: 0x40 }
-  - { offsetInCU: 0xF0, offset: 0x7A970, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5store_WZ', symObjAddr: 0x40, symBinAddr: 0xAC80, symSize: 0x30 }
-  - { offsetInCU: 0x135, offset: 0x7A9B5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5views33_508084857CA7D194CA72FEB80DD78002LL_WZ', symObjAddr: 0xA8, symBinAddr: 0xACE8, symSize: 0x40 }
-  - { offsetInCU: 0x187, offset: 0x7AA07, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC3ptrSvSgvgTo', symObjAddr: 0x194, symBinAddr: 0xADD4, symSize: 0x10 }
-  - { offsetInCU: 0x1A7, offset: 0x7AA27, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC3ptrSvSgvgTo', symObjAddr: 0x194, symBinAddr: 0xADD4, symSize: 0x10 }
-  - { offsetInCU: 0x1DD, offset: 0x7AA5D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC3ptrSvSgvsTo', symObjAddr: 0x1A4, symBinAddr: 0xADE4, symSize: 0x10 }
-  - { offsetInCU: 0x1FD, offset: 0x7AA7D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC3ptrSvSgvsTo', symObjAddr: 0x1A4, symBinAddr: 0xADE4, symSize: 0x10 }
-  - { offsetInCU: 0x236, offset: 0x7AAB6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6mtlPtrSvSgvgTo', symObjAddr: 0x1B4, symBinAddr: 0xADF4, symSize: 0x10 }
-  - { offsetInCU: 0x256, offset: 0x7AAD6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6mtlPtrSvSgvgTo', symObjAddr: 0x1B4, symBinAddr: 0xADF4, symSize: 0x10 }
-  - { offsetInCU: 0x28C, offset: 0x7AB0C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6mtlPtrSvSgvsTo', symObjAddr: 0x1C4, symBinAddr: 0xAE04, symSize: 0x10 }
-  - { offsetInCU: 0x2AC, offset: 0x7AB2C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6mtlPtrSvSgvsTo', symObjAddr: 0x1C4, symBinAddr: 0xAE04, symSize: 0x10 }
-  - { offsetInCU: 0x2E5, offset: 0x7AB65, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvgTo', symObjAddr: 0x29C, symBinAddr: 0xAEDC, symSize: 0x44 }
-  - { offsetInCU: 0x322, offset: 0x7ABA2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvsTo', symObjAddr: 0x324, symBinAddr: 0xAF64, symSize: 0x30 }
-  - { offsetInCU: 0x3B1, offset: 0x7AC31, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8nativeGLs5Int64VvgTo', symObjAddr: 0x578, symBinAddr: 0xB1B8, symSize: 0x44 }
-  - { offsetInCU: 0x409, offset: 0x7AC89, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8nativeGLs5Int64VvsTo', symObjAddr: 0x600, symBinAddr: 0xB240, symSize: 0x48 }
-  - { offsetInCU: 0x464, offset: 0x7ACE4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13nativeContexts5Int64VvgTo', symObjAddr: 0x648, symBinAddr: 0xB288, symSize: 0x44 }
-  - { offsetInCU: 0x4BC, offset: 0x7AD3C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13nativeContexts5Int64VvsTo', symObjAddr: 0x6D0, symBinAddr: 0xB310, symSize: 0x48 }
-  - { offsetInCU: 0x517, offset: 0x7AD97, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15native2DContexts5Int64VvgTo', symObjAddr: 0x718, symBinAddr: 0xB358, symSize: 0x10 }
-  - { offsetInCU: 0x537, offset: 0x7ADB7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15native2DContexts5Int64VvgTo', symObjAddr: 0x718, symBinAddr: 0xB358, symSize: 0x10 }
-  - { offsetInCU: 0x56D, offset: 0x7ADED, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15native2DContexts5Int64VvsTo', symObjAddr: 0x728, symBinAddr: 0xB368, symSize: 0x10 }
-  - { offsetInCU: 0x58D, offset: 0x7AE0D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15native2DContexts5Int64VvsTo', symObjAddr: 0x728, symBinAddr: 0xB368, symSize: 0x10 }
-  - { offsetInCU: 0x5C6, offset: 0x7AE46, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7mtlViewSo7MTKViewCvgTo', symObjAddr: 0x738, symBinAddr: 0xB378, symSize: 0x10 }
-  - { offsetInCU: 0x5E6, offset: 0x7AE66, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7mtlViewSo7MTKViewCvgTo', symObjAddr: 0x738, symBinAddr: 0xB378, symSize: 0x10 }
-  - { offsetInCU: 0x61E, offset: 0x7AE9E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7mtlViewSo7MTKViewCvsTo', symObjAddr: 0x748, symBinAddr: 0xB388, symSize: 0x34 }
-  - { offsetInCU: 0x677, offset: 0x7AEF7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7glkViewAA0A7GLKViewCvgTo', symObjAddr: 0x77C, symBinAddr: 0xB3BC, symSize: 0x10 }
-  - { offsetInCU: 0x697, offset: 0x7AF17, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7glkViewAA0A7GLKViewCvgTo', symObjAddr: 0x77C, symBinAddr: 0xB3BC, symSize: 0x10 }
-  - { offsetInCU: 0x6CF, offset: 0x7AF4F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7glkViewAA0A7GLKViewCvsTo', symObjAddr: 0x78C, symBinAddr: 0xB3CC, symSize: 0x34 }
-  - { offsetInCU: 0x728, offset: 0x7AFA8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC4is2DSbvgTo', symObjAddr: 0x7C0, symBinAddr: 0xB400, symSize: 0x10 }
-  - { offsetInCU: 0x748, offset: 0x7AFC8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC4is2DSbvgTo', symObjAddr: 0x7C0, symBinAddr: 0xB400, symSize: 0x10 }
-  - { offsetInCU: 0x77E, offset: 0x7AFFE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC4is2DSbvsTo', symObjAddr: 0x7D0, symBinAddr: 0xB410, symSize: 0x10 }
-  - { offsetInCU: 0x79E, offset: 0x7B01E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC4is2DSbvsTo', symObjAddr: 0x7D0, symBinAddr: 0xB410, symSize: 0x10 }
-  - { offsetInCU: 0x7D7, offset: 0x7B057, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7isMetalSbvgTo', symObjAddr: 0x7E0, symBinAddr: 0xB420, symSize: 0x10 }
-  - { offsetInCU: 0x7F7, offset: 0x7B077, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7isMetalSbvgTo', symObjAddr: 0x7E0, symBinAddr: 0xB420, symSize: 0x10 }
-  - { offsetInCU: 0x82D, offset: 0x7B0AD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7isMetalSbvsTo', symObjAddr: 0x7F0, symBinAddr: 0xB430, symSize: 0x10 }
-  - { offsetInCU: 0x84D, offset: 0x7B0CD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7isMetalSbvsTo', symObjAddr: 0x7F0, symBinAddr: 0xB430, symSize: 0x10 }
-  - { offsetInCU: 0x870, offset: 0x7B0F0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18drawingBufferWidthSivgTo', symObjAddr: 0x800, symBinAddr: 0xB440, symSize: 0x34 }
-  - { offsetInCU: 0x8A2, offset: 0x7B122, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19drawingBufferHeightSivgTo', symObjAddr: 0x904, symBinAddr: 0xB544, symSize: 0x34 }
-  - { offsetInCU: 0x8EA, offset: 0x7B16A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5widthSfvgTo', symObjAddr: 0xA08, symBinAddr: 0xB648, symSize: 0x20 }
-  - { offsetInCU: 0x952, offset: 0x7B1D2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6heightSfvgTo', symObjAddr: 0xA4C, symBinAddr: 0xB68C, symSize: 0x20 }
-  - { offsetInCU: 0x9F1, offset: 0x7B271, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11initContextyySS_S4bs5Int32VS5btFTo', symObjAddr: 0xAB4, symBinAddr: 0xB6F4, symSize: 0xC4 }
-  - { offsetInCU: 0xAB4, offset: 0x7B334, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17initWebGPUContextyys5Int64VFTo', symObjAddr: 0xD10, symBinAddr: 0xB950, symSize: 0x30 }
-  - { offsetInCU: 0xB64, offset: 0x7B3E4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC015initContextWithE10AttributesyySS_S4bs5Int32VS5btFTo', symObjAddr: 0x15C8, symBinAddr: 0xC208, symSize: 0xC4 }
-  - { offsetInCU: 0xBCE, offset: 0x7B44E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15create2DContextys5Int64VSb_S3bs5Int32VS5bAHtFTo', symObjAddr: 0x18E4, symBinAddr: 0xC524, symSize: 0xB0 }
-  - { offsetInCU: 0xC0B, offset: 0x7B48B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11forceLayoutyy12CoreGraphics7CGFloatV_AGtFTo', symObjAddr: 0x1A54, symBinAddr: 0xC694, symSize: 0xB8 }
-  - { offsetInCU: 0xC83, offset: 0x7B503, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8snapshotySo7UIImageCSgSbFTo', symObjAddr: 0x1BF0, symBinAddr: 0xC830, symSize: 0x3C }
-  - { offsetInCU: 0xCB6, offset: 0x7B536, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8rendererAA9NSCRenderCSgvgTo', symObjAddr: 0x1C2C, symBinAddr: 0xC86C, symSize: 0x10 }
-  - { offsetInCU: 0xCD6, offset: 0x7B556, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8rendererAA9NSCRenderCSgvgTo', symObjAddr: 0x1C2C, symBinAddr: 0xC86C, symSize: 0x10 }
-  - { offsetInCU: 0xD10, offset: 0x7B590, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8rendererAA9NSCRenderCSgvsTo', symObjAddr: 0x1C3C, symBinAddr: 0xC87C, symSize: 0x34 }
-  - { offsetInCU: 0xD6B, offset: 0x7B5EB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6renderSbyFTo', symObjAddr: 0x1CB8, symBinAddr: 0xC8F8, symSize: 0x48 }
-  - { offsetInCU: 0xE05, offset: 0x7B685, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13context2DTestyys5Int64VFTo', symObjAddr: 0x1D4C, symBinAddr: 0xC98C, symSize: 0x64 }
-  - { offsetInCU: 0xECA, offset: 0x7B74A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC22context2DTestToDataURLySSs5Int64VFTo', symObjAddr: 0x1E08, symBinAddr: 0xCA48, symSize: 0x94 }
-  - { offsetInCU: 0xF57, offset: 0x7B7D7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC23enterBackgroundListeneryycSgvsTo', symObjAddr: 0x1EDC, symBinAddr: 0xCB1C, symSize: 0x6C }
-  - { offsetInCU: 0xFB9, offset: 0x7B839, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC20becomeActiveListeneryycSgvsTo', symObjAddr: 0x1FEC, symBinAddr: 0xCC2C, symSize: 0x6C }
-  - { offsetInCU: 0x1016, offset: 0x7B896, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvgTo', symObjAddr: 0x2058, symBinAddr: 0xCC98, symSize: 0xB0 }
-  - { offsetInCU: 0x1068, offset: 0x7B8E8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvsTo', symObjAddr: 0x21D8, symBinAddr: 0xCE18, symSize: 0x94 }
-  - { offsetInCU: 0x10FA, offset: 0x7B97A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5coderACSgSo7NSCoderC_tcfcTo', symObjAddr: 0x2EC4, symBinAddr: 0xDB04, symSize: 0x28 }
-  - { offsetInCU: 0x114F, offset: 0x7B9CF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5frameACSo6CGRectV_tcfcTo', symObjAddr: 0x3944, symBinAddr: 0xE584, symSize: 0x20 }
-  - { offsetInCU: 0x1182, offset: 0x7BA02, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvgTo', symObjAddr: 0x3964, symBinAddr: 0xE5A4, symSize: 0x10 }
-  - { offsetInCU: 0x11A2, offset: 0x7BA22, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvgTo', symObjAddr: 0x3964, symBinAddr: 0xE5A4, symSize: 0x10 }
-  - { offsetInCU: 0x11DA, offset: 0x7BA5A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvsTo', symObjAddr: 0x3974, symBinAddr: 0xE5B4, symSize: 0x34 }
-  - { offsetInCU: 0x1248, offset: 0x7BAC8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13readyListenerAA0cE0_pSgvgTo', symObjAddr: 0x3A28, symBinAddr: 0xE668, symSize: 0x20 }
-  - { offsetInCU: 0x12A2, offset: 0x7BB22, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13readyListenerAA0cE0_pSgvsTo', symObjAddr: 0x3A48, symBinAddr: 0xE688, symSize: 0x34 }
-  - { offsetInCU: 0x1302, offset: 0x7BB82, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11setListeneryyAA0cE0_pSgFTo', symObjAddr: 0x3AAC, symBinAddr: 0xE6EC, symSize: 0x34 }
-  - { offsetInCU: 0x1446, offset: 0x7BCC6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC14layoutSubviewsyyFTo', symObjAddr: 0x3DF8, symBinAddr: 0xEA38, symSize: 0x28 }
-  - { offsetInCU: 0x1479, offset: 0x7BCF9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCfDTo', symObjAddr: 0x4124, symBinAddr: 0xED64, symSize: 0x24 }
-  - { offsetInCU: 0x14B4, offset: 0x7BD34, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC21getBoundingClientRectyySo6UIViewC_SvtFZTo', symObjAddr: 0x4210, symBinAddr: 0xEE50, symSize: 0x34 }
-  - { offsetInCU: 0x14E7, offset: 0x7BD67, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC14shared_context33_508084857CA7D194CA72FEB80DD78002LLs5Int64VvgZTf4d_n', symObjAddr: 0x4BAC, symBinAddr: 0xF7EC, symSize: 0x2A8 }
-  - { offsetInCU: 0x1664, offset: 0x7BEE4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC21getBoundingClientRectyySo6UIViewC_SvtFZTf4nnd_n', symObjAddr: 0x4F18, symBinAddr: 0xFB58, symSize: 0xA0 }
-  - { offsetInCU: 0x18E0, offset: 0x7C160, size: 0x8, addend: 0x0, symName: '_$sIeg_IeyB_TR', symObjAddr: 0x1EB0, symBinAddr: 0xCAF0, symSize: 0x2C }
-  - { offsetInCU: 0x18F8, offset: 0x7C178, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_So8NSStringCABIeyByy_TR', symObjAddr: 0x2160, symBinAddr: 0xCDA0, symSize: 0x78 }
-  - { offsetInCU: 0x1910, offset: 0x7C190, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvpACTK', symObjAddr: 0x22C8, symBinAddr: 0xCF08, symSize: 0x94 }
-  - { offsetInCU: 0x1948, offset: 0x7C1C8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvpACTk', symObjAddr: 0x235C, symBinAddr: 0xCF9C, symSize: 0xB8 }
-  - { offsetInCU: 0x198A, offset: 0x7C20A, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCytIegnnr_SSABIeggg_TR', symObjAddr: 0x2414, symBinAddr: 0xD054, symSize: 0x6C }
-  - { offsetInCU: 0x1A3A, offset: 0x7C2BA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCfETo', symObjAddr: 0x4148, symBinAddr: 0xED88, symSize: 0xC4 }
-  - { offsetInCU: 0x1A6A, offset: 0x7C2EA, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_SgWOy', symObjAddr: 0x4244, symBinAddr: 0xEE84, symSize: 0x10 }
-  - { offsetInCU: 0x1A7E, offset: 0x7C2FE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCMa', symObjAddr: 0x4254, symBinAddr: 0xEE94, symSize: 0x20 }
-  - { offsetInCU: 0x1A92, offset: 0x7C312, size: 0x8, addend: 0x0, symName: '_$ss29getContiguousArrayStorageType3fors01_bcD0CyxGmxm_tlFSo18NSLayoutConstraintC_Tgm5', symObjAddr: 0x4274, symBinAddr: 0xEEB4, symSize: 0x64 }
-  - { offsetInCU: 0x1C99, offset: 0x7C519, size: 0x8, addend: 0x0, symName: ___swift_instantiateConcreteTypeFromMangledName, symObjAddr: 0x4E54, symBinAddr: 0xFA94, symSize: 0x40 }
-  - { offsetInCU: 0x1CAD, offset: 0x7C52D, size: 0x8, addend: 0x0, symName: '_$sypSgWOh', symObjAddr: 0x4E94, symBinAddr: 0xFAD4, symSize: 0x40 }
-  - { offsetInCU: 0x1CC1, offset: 0x7C541, size: 0x8, addend: 0x0, symName: ___swift_project_boxed_opaque_existential_0, symObjAddr: 0x4ED4, symBinAddr: 0xFB14, symSize: 0x24 }
-  - { offsetInCU: 0x1CD5, offset: 0x7C555, size: 0x8, addend: 0x0, symName: ___swift_destroy_boxed_opaque_existential_0, symObjAddr: 0x4EF8, symBinAddr: 0xFB38, symSize: 0x20 }
-  - { offsetInCU: 0x1CF4, offset: 0x7C574, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSo19UIGestureRecognizerCIeyByy_SSADIeggg_TRTA', symObjAddr: 0x53E4, symBinAddr: 0x10024, symSize: 0x48 }
-  - { offsetInCU: 0x1D1D, offset: 0x7C59D, size: 0x8, addend: 0x0, symName: _block_copy_helper, symObjAddr: 0x542C, symBinAddr: 0x1006C, symSize: 0x10 }
-  - { offsetInCU: 0x1D31, offset: 0x7C5B1, size: 0x8, addend: 0x0, symName: _block_destroy_helper, symObjAddr: 0x543C, symBinAddr: 0x1007C, symSize: 0x8 }
-  - { offsetInCU: 0x1D45, offset: 0x7C5C5, size: 0x8, addend: 0x0, symName: '_$sIeg_SgWOe', symObjAddr: 0x5444, symBinAddr: 0x10084, symSize: 0x10 }
-  - { offsetInCU: 0x1D64, offset: 0x7C5E4, size: 0x8, addend: 0x0, symName: '_$sIeyB_Ieg_TRTA', symObjAddr: 0x5454, symBinAddr: 0x10094, symSize: 0xC }
-  - { offsetInCU: 0x1D8D, offset: 0x7C60D, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCytIegnnr_SSABIeggg_TRTA', symObjAddr: 0x5484, symBinAddr: 0x100C4, symSize: 0x8 }
-  - { offsetInCU: 0x1DAC, offset: 0x7C62C, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_SSABytIegnnr_TRTA', symObjAddr: 0x548C, symBinAddr: 0x100CC, symSize: 0x30 }
-  - { offsetInCU: 0x1DD5, offset: 0x7C655, size: 0x8, addend: 0x0, symName: '_$sypWOb', symObjAddr: 0x54BC, symBinAddr: 0x100FC, symSize: 0x10 }
-  - { offsetInCU: 0x1DE9, offset: 0x7C669, size: 0x8, addend: 0x0, symName: '_$sypWOc', symObjAddr: 0x5504, symBinAddr: 0x10144, symSize: 0x3C }
-  - { offsetInCU: 0x206E, offset: 0x7C8EE, size: 0x8, addend: 0x0, symName: '_$sSD17dictionaryLiteralSDyxq_Gx_q_td_tcfCSS_ypTgm5Tf4g_n', symObjAddr: 0x4A94, symBinAddr: 0xF6D4, symSize: 0x118 }
-  - { offsetInCU: 0x2514, offset: 0x7CD94, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvg', symObjAddr: 0x2E0, symBinAddr: 0xAF20, symSize: 0x44 }
-  - { offsetInCU: 0x2547, offset: 0x7CDC7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvs', symObjAddr: 0x354, symBinAddr: 0xAF94, symSize: 0xEC }
-  - { offsetInCU: 0x2593, offset: 0x7CE13, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvM', symObjAddr: 0x440, symBinAddr: 0xB080, symSize: 0x58 }
-  - { offsetInCU: 0x25B8, offset: 0x7CE38, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvM.resume.0', symObjAddr: 0x498, symBinAddr: 0xB0D8, symSize: 0xE0 }
-  - { offsetInCU: 0x25F9, offset: 0x7CE79, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8nativeGLs5Int64Vvg', symObjAddr: 0x5BC, symBinAddr: 0xB1FC, symSize: 0x44 }
-  - { offsetInCU: 0x2651, offset: 0x7CED1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13nativeContexts5Int64Vvg', symObjAddr: 0x68C, symBinAddr: 0xB2CC, symSize: 0x44 }
-  - { offsetInCU: 0x27BF, offset: 0x7D03F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18drawingBufferWidthSivg', symObjAddr: 0x834, symBinAddr: 0xB474, symSize: 0xD0 }
-  - { offsetInCU: 0x28E4, offset: 0x7D164, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19drawingBufferHeightSivg', symObjAddr: 0x938, symBinAddr: 0xB578, symSize: 0xD0 }
-  - { offsetInCU: 0x2A2A, offset: 0x7D2AA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5widthSfvg', symObjAddr: 0xA28, symBinAddr: 0xB668, symSize: 0x24 }
-  - { offsetInCU: 0x2A72, offset: 0x7D2F2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6heightSfvg', symObjAddr: 0xA6C, symBinAddr: 0xB6AC, symSize: 0x24 }
-  - { offsetInCU: 0x2AA6, offset: 0x7D326, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11initContextyySS_S4bs5Int32VS5btF', symObjAddr: 0xA90, symBinAddr: 0xB6D0, symSize: 0x24 }
-  - { offsetInCU: 0x2C34, offset: 0x7D4B4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17initWebGPUContextyys5Int64VF', symObjAddr: 0xB78, symBinAddr: 0xB7B8, symSize: 0x198 }
-  - { offsetInCU: 0x3027, offset: 0x7D8A7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC015initContextWithE10AttributesyySS_S4bs5Int32VS5btF', symObjAddr: 0xD40, symBinAddr: 0xB980, symSize: 0x888 }
-  - { offsetInCU: 0x382A, offset: 0x7E0AA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15create2DContextys5Int64VSb_S3bs5Int32VS5bAHtF', symObjAddr: 0x168C, symBinAddr: 0xC2CC, symSize: 0x258 }
-  - { offsetInCU: 0x3C5C, offset: 0x7E4DC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11forceLayoutyy12CoreGraphics7CGFloatV_AGtF', symObjAddr: 0x1994, symBinAddr: 0xC5D4, symSize: 0xC0 }
-  - { offsetInCU: 0x3CED, offset: 0x7E56D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8snapshotySo7UIImageCSgSbF', symObjAddr: 0x1B0C, symBinAddr: 0xC74C, symSize: 0xE4 }
-  - { offsetInCU: 0x3E48, offset: 0x7E6C8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6renderSbyF', symObjAddr: 0x1C70, symBinAddr: 0xC8B0, symSize: 0x48 }
-  - { offsetInCU: 0x3ECE, offset: 0x7E74E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13context2DTestyys5Int64VF', symObjAddr: 0x1D00, symBinAddr: 0xC940, symSize: 0x4C }
-  - { offsetInCU: 0x3FEF, offset: 0x7E86F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC22context2DTestToDataURLySSs5Int64VF', symObjAddr: 0x1DB0, symBinAddr: 0xC9F0, symSize: 0x58 }
-  - { offsetInCU: 0x40E5, offset: 0x7E965, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvg', symObjAddr: 0x2108, symBinAddr: 0xCD48, symSize: 0x58 }
-  - { offsetInCU: 0x4131, offset: 0x7E9B1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvs', symObjAddr: 0x226C, symBinAddr: 0xCEAC, symSize: 0x5C }
-  - { offsetInCU: 0x415A, offset: 0x7E9DA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvM', symObjAddr: 0x2480, symBinAddr: 0xD0C0, symSize: 0x44 }
-  - { offsetInCU: 0x4180, offset: 0x7EA00, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvM.resume.0', symObjAddr: 0x24C4, symBinAddr: 0xD104, symSize: 0x4 }
-  - { offsetInCU: 0x4242, offset: 0x7EAC2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5coderACSgSo7NSCoderC_tcfc', symObjAddr: 0x24C8, symBinAddr: 0xD108, symSize: 0x9FC }
-  - { offsetInCU: 0x4465, offset: 0x7ECE5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5frameACSo6CGRectV_tcfC', symObjAddr: 0x2EEC, symBinAddr: 0xDB2C, symSize: 0x50 }
-  - { offsetInCU: 0x448E, offset: 0x7ED0E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5frameACSo6CGRectV_tcfc', symObjAddr: 0x2F3C, symBinAddr: 0xDB7C, symSize: 0xA08 }
-  - { offsetInCU: 0x46D2, offset: 0x7EF52, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvW', symObjAddr: 0x39A8, symBinAddr: 0xE5E8, symSize: 0x80 }
-  - { offsetInCU: 0x47C8, offset: 0x7F048, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11setListeneryyAA0cE0_pSgF', symObjAddr: 0x3A7C, symBinAddr: 0xE6BC, symSize: 0x30 }
-  - { offsetInCU: 0x4866, offset: 0x7F0E6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6resize33_508084857CA7D194CA72FEB80DD78002LLyyF', symObjAddr: 0x3AE0, symBinAddr: 0xE720, symSize: 0x144 }
-  - { offsetInCU: 0x4A67, offset: 0x7F2E7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC14layoutSubviewsyyF', symObjAddr: 0x3C24, symBinAddr: 0xE864, symSize: 0x1D4 }
-  - { offsetInCU: 0x4CE4, offset: 0x7F564, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCfD', symObjAddr: 0x3E20, symBinAddr: 0xEA60, symSize: 0x304 }
-  - { offsetInCU: 0x4D74, offset: 0x7F5F4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC21getBoundingClientRectyySo6UIViewC_SvtFZ', symObjAddr: 0x420C, symBinAddr: 0xEE4C, symSize: 0x4 }
-  - { offsetInCU: 0x4D9C, offset: 0x7F61C, size: 0x8, addend: 0x0, symName: '_$ss22__RawDictionaryStorageC4findys10_HashTableV6BucketV6bucket_Sb5foundtxSHRzlFSS_Tg5', symObjAddr: 0x42D8, symBinAddr: 0xEF18, symSize: 0x64 }
-  - { offsetInCU: 0x4DF6, offset: 0x7F676, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV7_insert2at3key5valueys10_HashTableV6BucketV_xnq_ntFSS_ypTg5', symObjAddr: 0x433C, symBinAddr: 0xEF7C, symSize: 0x6C }
-  - { offsetInCU: 0x4E76, offset: 0x7F6F6, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV12mutatingFind_8isUniques10_HashTableV6BucketV6bucket_Sb5foundtx_SbtFSS_ypTg5', symObjAddr: 0x43A8, symBinAddr: 0xEFE8, symSize: 0xD8 }
-  - { offsetInCU: 0x4EB3, offset: 0x7F733, size: 0x8, addend: 0x0, symName: '_$ss22__RawDictionaryStorageC4find_9hashValues10_HashTableV6BucketV6bucket_Sb5foundtx_SitSHRzlFSS_Tg5', symObjAddr: 0x4480, symBinAddr: 0xF0C0, symSize: 0xE0 }
-  - { offsetInCU: 0x4F2E, offset: 0x7F7AE, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV4copyyyFSS_ypTg5', symObjAddr: 0x4560, symBinAddr: 0xF1A0, symSize: 0x1F4 }
-  - { offsetInCU: 0x4FEA, offset: 0x7F86A, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV20_copyOrMoveAndResize8capacity12moveElementsySi_SbtFSS_ypTg5', symObjAddr: 0x4754, symBinAddr: 0xF394, symSize: 0x340 }
-  - { offsetInCU: 0x27, offset: 0x7FAD2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative7GLUtilsCfD', symObjAddr: 0x0, symBinAddr: 0x101E4, symSize: 0x10 }
-  - { offsetInCU: 0x62, offset: 0x7FB0D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative7GLUtilsCMa', symObjAddr: 0x10, symBinAddr: 0x101F4, symSize: 0x20 }
-  - { offsetInCU: 0x1AF, offset: 0x7FC5A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative7GLUtilsCfD', symObjAddr: 0x0, symBinAddr: 0x101E4, symSize: 0x10 }
-  - { offsetInCU: 0x65, offset: 0x7FCE9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8mPrograms6UInt32VvgTo', symObjAddr: 0x0, symBinAddr: 0x10214, symSize: 0x10 }
-  - { offsetInCU: 0x85, offset: 0x7FD09, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8mPrograms6UInt32VvgTo', symObjAddr: 0x0, symBinAddr: 0x10214, symSize: 0x10 }
-  - { offsetInCU: 0xBB, offset: 0x7FD3F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8mPrograms6UInt32VvsTo', symObjAddr: 0x10, symBinAddr: 0x10224, symSize: 0x10 }
-  - { offsetInCU: 0xDB, offset: 0x7FD5F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8mPrograms6UInt32VvsTo', symObjAddr: 0x10, symBinAddr: 0x10224, symSize: 0x10 }
-  - { offsetInCU: 0x114, offset: 0x7FD98, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3rbos6UInt32VvgTo', symObjAddr: 0x20, symBinAddr: 0x10234, symSize: 0x44 }
-  - { offsetInCU: 0x16C, offset: 0x7FDF0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3rbos6UInt32VvsTo', symObjAddr: 0x64, symBinAddr: 0x10278, symSize: 0x48 }
-  - { offsetInCU: 0x1C7, offset: 0x7FE4B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3fbos6UInt32VvgTo', symObjAddr: 0xAC, symBinAddr: 0x102C0, symSize: 0x44 }
-  - { offsetInCU: 0x21F, offset: 0x7FEA3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3fbos6UInt32VvsTo', symObjAddr: 0xF0, symBinAddr: 0x10304, symSize: 0x48 }
-  - { offsetInCU: 0x27A, offset: 0x7FEFE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC5widthSivgTo', symObjAddr: 0x138, symBinAddr: 0x1034C, symSize: 0x10 }
-  - { offsetInCU: 0x29A, offset: 0x7FF1E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC5widthSivgTo', symObjAddr: 0x138, symBinAddr: 0x1034C, symSize: 0x10 }
-  - { offsetInCU: 0x2D0, offset: 0x7FF54, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC5widthSivsTo', symObjAddr: 0x148, symBinAddr: 0x1035C, symSize: 0x10 }
-  - { offsetInCU: 0x2F0, offset: 0x7FF74, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC5widthSivsTo', symObjAddr: 0x148, symBinAddr: 0x1035C, symSize: 0x10 }
-  - { offsetInCU: 0x329, offset: 0x7FFAD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC6heightSivgTo', symObjAddr: 0x158, symBinAddr: 0x1036C, symSize: 0x10 }
-  - { offsetInCU: 0x349, offset: 0x7FFCD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC6heightSivgTo', symObjAddr: 0x158, symBinAddr: 0x1036C, symSize: 0x10 }
-  - { offsetInCU: 0x37F, offset: 0x80003, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC6heightSivsTo', symObjAddr: 0x168, symBinAddr: 0x1037C, symSize: 0x10 }
-  - { offsetInCU: 0x39F, offset: 0x80023, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC6heightSivsTo', symObjAddr: 0x168, symBinAddr: 0x1037C, symSize: 0x10 }
-  - { offsetInCU: 0x3D8, offset: 0x8005C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC2abs6UInt32VvgTo', symObjAddr: 0x178, symBinAddr: 0x1038C, symSize: 0x44 }
-  - { offsetInCU: 0x430, offset: 0x800B4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC2abs6UInt32VvsTo', symObjAddr: 0x1BC, symBinAddr: 0x103D0, symSize: 0x48 }
-  - { offsetInCU: 0x48B, offset: 0x8010F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3poss5Int32VvgTo', symObjAddr: 0x204, symBinAddr: 0x10418, symSize: 0x10 }
-  - { offsetInCU: 0x4AB, offset: 0x8012F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3poss5Int32VvgTo', symObjAddr: 0x204, symBinAddr: 0x10418, symSize: 0x10 }
-  - { offsetInCU: 0x4E1, offset: 0x80165, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3poss5Int32VvsTo', symObjAddr: 0x214, symBinAddr: 0x10428, symSize: 0x10 }
-  - { offsetInCU: 0x501, offset: 0x80185, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3poss5Int32VvsTo', symObjAddr: 0x214, symBinAddr: 0x10428, symSize: 0x10 }
-  - { offsetInCU: 0x53A, offset: 0x801BE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10samplerPoss5Int32VvgTo', symObjAddr: 0x224, symBinAddr: 0x10438, symSize: 0x10 }
-  - { offsetInCU: 0x55A, offset: 0x801DE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10samplerPoss5Int32VvgTo', symObjAddr: 0x224, symBinAddr: 0x10438, symSize: 0x10 }
-  - { offsetInCU: 0x590, offset: 0x80214, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10samplerPoss5Int32VvsTo', symObjAddr: 0x234, symBinAddr: 0x10448, symSize: 0x10 }
-  - { offsetInCU: 0x5B0, offset: 0x80234, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10samplerPoss5Int32VvsTo', symObjAddr: 0x234, symBinAddr: 0x10448, symSize: 0x10 }
-  - { offsetInCU: 0x5E9, offset: 0x8026D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9vextexBufSaySfGvgTo', symObjAddr: 0x244, symBinAddr: 0x10458, symSize: 0x48 }
-  - { offsetInCU: 0x63F, offset: 0x802C3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9vextexBufSaySfGvsTo', symObjAddr: 0x28C, symBinAddr: 0x104A0, symSize: 0x40 }
-  - { offsetInCU: 0x682, offset: 0x80306, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13SIZE_OF_FLOATSivgZTo', symObjAddr: 0x2CC, symBinAddr: 0x104E0, symSize: 0x8 }
-  - { offsetInCU: 0x69E, offset: 0x80322, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13VERTEX_SHADERSSvgZTo', symObjAddr: 0x2D4, symBinAddr: 0x104E8, symSize: 0x2C }
-  - { offsetInCU: 0x6D0, offset: 0x80354, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7surfaceSo9IOSurfaceCSgvgTo', symObjAddr: 0x300, symBinAddr: 0x10514, symSize: 0x10 }
-  - { offsetInCU: 0x6F0, offset: 0x80374, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7surfaceSo9IOSurfaceCSgvgTo', symObjAddr: 0x300, symBinAddr: 0x10514, symSize: 0x10 }
-  - { offsetInCU: 0x728, offset: 0x803AC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7surfaceSo9IOSurfaceCSgvsTo', symObjAddr: 0x310, symBinAddr: 0x10524, symSize: 0x34 }
-  - { offsetInCU: 0x781, offset: 0x80405, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8pixelBufs9UnmanagedVySo11CVBufferRefaGSgvgTo', symObjAddr: 0x418, symBinAddr: 0x1062C, symSize: 0x10 }
-  - { offsetInCU: 0x7A1, offset: 0x80425, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8pixelBufs9UnmanagedVySo11CVBufferRefaGSgvgTo', symObjAddr: 0x418, symBinAddr: 0x1062C, symSize: 0x10 }
-  - { offsetInCU: 0x7D7, offset: 0x8045B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8pixelBufs9UnmanagedVySo11CVBufferRefaGSgvsTo', symObjAddr: 0x428, symBinAddr: 0x1063C, symSize: 0x10 }
-  - { offsetInCU: 0x7F7, offset: 0x8047B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8pixelBufs9UnmanagedVySo11CVBufferRefaGSgvsTo', symObjAddr: 0x428, symBinAddr: 0x1063C, symSize: 0x10 }
-  - { offsetInCU: 0x846, offset: 0x804CA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCACycfcTo', symObjAddr: 0x5BC, symBinAddr: 0x10790, symSize: 0x20 }
-  - { offsetInCU: 0x878, offset: 0x804FC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7destroyyyFTo', symObjAddr: 0x720, symBinAddr: 0x108F4, symSize: 0x28 }
-  - { offsetInCU: 0x8D0, offset: 0x80554, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10texImage2Dyys5Int32V_A4fA9NSCCanvasCAHSbtFTo', symObjAddr: 0x75C, symBinAddr: 0x10930, symSize: 0x88 }
-  - { offsetInCU: 0x934, offset: 0x805B8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9drawFrame6buffer5width6height14internalFormat6format10flipYWebGLySo11CVBufferRefa_S2is5Int32VANSbtFTo', symObjAddr: 0x7E4, symBinAddr: 0x109B8, symSize: 0x7C }
-  - { offsetInCU: 0x9D6, offset: 0x8065A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13createSurfaceyyFTo', symObjAddr: 0xC0C, symBinAddr: 0x10DE0, symSize: 0x28 }
-  - { offsetInCU: 0xAC0, offset: 0x80744, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCMa', symObjAddr: 0x59C, symBinAddr: 0x10770, symSize: 0x20 }
-  - { offsetInCU: 0xB34, offset: 0x807B8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCfETo', symObjAddr: 0xC64, symBinAddr: 0x10E38, symSize: 0x58 }
-  - { offsetInCU: 0x123B, offset: 0x80EBF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCACycfC', symObjAddr: 0x438, symBinAddr: 0x1064C, symSize: 0x20 }
-  - { offsetInCU: 0x1255, offset: 0x80ED9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCACycfc', symObjAddr: 0x458, symBinAddr: 0x1066C, symSize: 0x104 }
-  - { offsetInCU: 0x1287, offset: 0x80F0B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7destroyyyF', symObjAddr: 0x5DC, symBinAddr: 0x107B0, symSize: 0x144 }
-  - { offsetInCU: 0x1442, offset: 0x810C6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10texImage2Dyys5Int32V_A4fA9NSCCanvasCAHSbtF', symObjAddr: 0x748, symBinAddr: 0x1091C, symSize: 0x14 }
-  - { offsetInCU: 0x14F3, offset: 0x81177, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13createSurfaceyyF', symObjAddr: 0x860, symBinAddr: 0x10A34, symSize: 0x3AC }
-  - { offsetInCU: 0x1863, offset: 0x814E7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCfD', symObjAddr: 0xC34, symBinAddr: 0x10E08, symSize: 0x30 }
-  - { offsetInCU: 0x194E, offset: 0x815D2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10texImage2Dyys5Int32V_A4fA9NSCCanvasCAHSbtFTf4ddnndnndn_n', symObjAddr: 0xCBC, symBinAddr: 0x10E90, symSize: 0x65C }
-  - { offsetInCU: 0x214C, offset: 0x81DD0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9drawFrame6buffer5width6height14internalFormat6format10flipYWebGLySo11CVBufferRefa_S2is5Int32VANSbtFTf4nnnnndn_n', symObjAddr: 0x135C, symBinAddr: 0x11530, symSize: 0x6C8 }
-  - { offsetInCU: 0x10C, offset: 0x82790, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC6target6actionAEypSg_10ObjectiveC8SelectorVSgtcfcTo', symObjAddr: 0xED4, symBinAddr: 0x12AA4, symSize: 0x68 }
-  - { offsetInCU: 0x19C, offset: 0x82820, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerCfETo', symObjAddr: 0xF48, symBinAddr: 0x12B18, symSize: 0x10 }
-  - { offsetInCU: 0x1CB, offset: 0x8284F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC6handleyySo19UIGestureRecognizerCFTo', symObjAddr: 0xF58, symBinAddr: 0x12B28, symSize: 0x4 }
-  - { offsetInCU: 0x368, offset: 0x829EC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerCACycfcTo', symObjAddr: 0x16DC, symBinAddr: 0x132AC, symSize: 0x2C }
-  - { offsetInCU: 0x5D4, offset: 0x82C58, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerCfETo', symObjAddr: 0x1744, symBinAddr: 0x13314, symSize: 0x68 }
-  - { offsetInCU: 0x603, offset: 0x82C87, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerCMa', symObjAddr: 0x17AC, symBinAddr: 0x1337C, symSize: 0x20 }
-  - { offsetInCU: 0x617, offset: 0x82C9B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerCMa', symObjAddr: 0x17CC, symBinAddr: 0x1339C, symSize: 0x20 }
-  - { offsetInCU: 0x62B, offset: 0x82CAF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwCP', symObjAddr: 0x17EC, symBinAddr: 0x133BC, symSize: 0x30 }
-  - { offsetInCU: 0x63F, offset: 0x82CC3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwxx', symObjAddr: 0x181C, symBinAddr: 0x133EC, symSize: 0x8 }
-  - { offsetInCU: 0x653, offset: 0x82CD7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwcp', symObjAddr: 0x1824, symBinAddr: 0x133F4, symSize: 0x3C }
-  - { offsetInCU: 0x667, offset: 0x82CEB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwca', symObjAddr: 0x1860, symBinAddr: 0x13430, symSize: 0x50 }
-  - { offsetInCU: 0x67B, offset: 0x82CFF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwta', symObjAddr: 0x18BC, symBinAddr: 0x13480, symSize: 0x40 }
-  - { offsetInCU: 0x68F, offset: 0x82D13, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwet', symObjAddr: 0x18FC, symBinAddr: 0x134C0, symSize: 0x48 }
-  - { offsetInCU: 0x6A3, offset: 0x82D27, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwst', symObjAddr: 0x1944, symBinAddr: 0x13508, symSize: 0x40 }
-  - { offsetInCU: 0x6B7, offset: 0x82D3B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVMa', symObjAddr: 0x1984, symBinAddr: 0x13548, symSize: 0x10 }
-  - { offsetInCU: 0x6CB, offset: 0x82D4F, size: 0x8, addend: 0x0, symName: '_$sypSgWOc', symObjAddr: 0x1994, symBinAddr: 0x13558, symSize: 0x48 }
-  - { offsetInCU: 0x6DF, offset: 0x82D63, size: 0x8, addend: 0x0, symName: '_$sSo7UITouchCSo8NSObjectCSH10ObjectiveCWl', symObjAddr: 0x1AA0, symBinAddr: 0x135A0, symSize: 0x58 }
-  - { offsetInCU: 0x6F3, offset: 0x82D77, size: 0x8, addend: 0x0, symName: '_$sSh8IteratorV8_VariantOyx__GSHRzlWOe', symObjAddr: 0x1AF8, symBinAddr: 0x135F8, symSize: 0x8 }
-  - { offsetInCU: 0x761, offset: 0x82DE5, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_SgWOe', symObjAddr: 0x1DEC, symBinAddr: 0x138EC, symSize: 0x10 }
-  - { offsetInCU: 0xCBB, offset: 0x8333F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC12touchesBegan_4withyShySo7UITouchCG_So7UIEventCtF', symObjAddr: 0x0, symBinAddr: 0x11BF8, symSize: 0x540 }
-  - { offsetInCU: 0xF57, offset: 0x835DB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC12touchesMoved_4withyShySo7UITouchCG_So7UIEventCtF', symObjAddr: 0x54C, symBinAddr: 0x12144, symSize: 0xE0 }
-  - { offsetInCU: 0xFD6, offset: 0x8365A, size: 0x8, addend: 0x0, symName: '_$sSa6remove2atxSi_tF12CanvasNative15NSCTouchHandlerC7PointerV_Tg5', symObjAddr: 0x6F0, symBinAddr: 0x122D4, symSize: 0x9C }
-  - { offsetInCU: 0x1069, offset: 0x836ED, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC6target6actionAEypSg_10ObjectiveC8SelectorVSgtcfc', symObjAddr: 0xDCC, symBinAddr: 0x1299C, symSize: 0x108 }
-  - { offsetInCU: 0x11B3, offset: 0x83837, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC6onMove33_044DDF836BDB3B89B481C6F58BB6EF6BLLyySo19UIGestureRecognizerC_ShySo7UITouchCGSgtF', symObjAddr: 0x12D0, symBinAddr: 0x12EA0, symSize: 0x40C }
-  - { offsetInCU: 0x18C9, offset: 0x83F4D, size: 0x8, addend: 0x0, symName: '_$ss12_ArrayBufferV20_consumeAndCreateNewAByxGyF12CanvasNative15NSCTouchHandlerC7PointerV_Tg5', symObjAddr: 0x1B00, symBinAddr: 0x13600, symSize: 0x14 }
-  - { offsetInCU: 0x1968, offset: 0x83FEC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC6canvasAcA9NSCCanvasC_tcfcTf4gn_n', symObjAddr: 0x1B14, symBinAddr: 0x13614, symSize: 0x1E4 }
-  - { offsetInCU: 0x27, offset: 0x841C9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC14FAILED_TO_LOADSSvgZTo', symObjAddr: 0x0, symBinAddr: 0x138FC, symSize: 0x2C }
-  - { offsetInCU: 0x4B, offset: 0x841ED, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queueSo012OS_dispatch_E0CvpZ', symObjAddr: 0x2D8, symBinAddr: 0x10D3D08, symSize: 0x0 }
-  - { offsetInCU: 0x65, offset: 0x84207, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC14FAILED_TO_LOADSSvgZTo', symObjAddr: 0x0, symBinAddr: 0x138FC, symSize: 0x2C }
-  - { offsetInCU: 0x98, offset: 0x8423A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queueSo012OS_dispatch_E0CvgZTo', symObjAddr: 0x178, symBinAddr: 0x13A74, symSize: 0x40 }
-  - { offsetInCU: 0x104, offset: 0x842A6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCACycfcTo', symObjAddr: 0x228, symBinAddr: 0x13B24, symSize: 0x3C }
-  - { offsetInCU: 0x156, offset: 0x842F8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queue_WZ', symObjAddr: 0x2C, symBinAddr: 0x13928, symSize: 0x10C }
-  - { offsetInCU: 0x181, offset: 0x84323, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCMa', symObjAddr: 0x208, symBinAddr: 0x13B04, symSize: 0x20 }
-  - { offsetInCU: 0x195, offset: 0x84337, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCfETo', symObjAddr: 0x294, symBinAddr: 0x13B90, symSize: 0x4 }
-  - { offsetInCU: 0x1C0, offset: 0x84362, size: 0x8, addend: 0x0, symName: '_$sSo17OS_dispatch_queueCMa', symObjAddr: 0x298, symBinAddr: 0x13B94, symSize: 0x3C }
-  - { offsetInCU: 0x348, offset: 0x844EA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queueSo012OS_dispatch_E0CvgZ', symObjAddr: 0x138, symBinAddr: 0x13A34, symSize: 0x40 }
-  - { offsetInCU: 0x388, offset: 0x8452A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCACycfC', symObjAddr: 0x1B8, symBinAddr: 0x13AB4, symSize: 0x20 }
-  - { offsetInCU: 0x39C, offset: 0x8453E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCACycfc', symObjAddr: 0x1D8, symBinAddr: 0x13AD4, symSize: 0x30 }
-  - { offsetInCU: 0x3D8, offset: 0x8457A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCfD', symObjAddr: 0x264, symBinAddr: 0x13B60, symSize: 0x30 }
-  - { offsetInCU: 0x2B, offset: 0x845C8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC18createTextureCacheSo017CVOpenGLESTextureF3RefaSgyFZ', symObjAddr: 0x0, symBinAddr: 0x13BD0, symSize: 0xA4 }
-  - { offsetInCU: 0x66, offset: 0x84603, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC18createTextureCacheSo017CVOpenGLESTextureF3RefaSgyFZTo', symObjAddr: 0xA4, symBinAddr: 0x13C74, symSize: 0xA4 }
-  - { offsetInCU: 0xF9, offset: 0x84696, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11createImageySo11CVBufferRefaSgSo022CVOpenGLESTextureCacheG0a_AFSo012CFDictionaryG0aSgs6UInt32Vs5Int32VA2p2NSitFZTo', symObjAddr: 0x1D8, symBinAddr: 0x13DA8, symSize: 0x110 }
-  - { offsetInCU: 0x1A2, offset: 0x8473F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11setupRenderAA9NSCRenderCyFZTo', symObjAddr: 0x30C, symBinAddr: 0x13EDC, symSize: 0x28 }
-  - { offsetInCU: 0x222, offset: 0x847BF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC9drawFrameyySo8AVPlayerC_So0F15ItemVideoOutputCSo6CGSizeVAA9NSCRenderCs5Int32VANSbtFZTo', symObjAddr: 0x338, symBinAddr: 0x13F08, symSize: 0xA0 }
-  - { offsetInCU: 0x29B, offset: 0x84838, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11writeToFileyySo6NSDataC_SStKFZTo', symObjAddr: 0x4D0, symBinAddr: 0x140A0, symSize: 0x15C }
-  - { offsetInCU: 0x330, offset: 0x848CD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCACycfcTo', symObjAddr: 0x67C, symBinAddr: 0x1424C, symSize: 0x3C }
-  - { offsetInCU: 0x381, offset: 0x8491E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC9drawFrameyySo8AVPlayerC_So0F15ItemVideoOutputCSo6CGSizeVAA9NSCRenderCs5Int32VANSbtFZTf4nnnnnndd_n', symObjAddr: 0x6E8, symBinAddr: 0x142B8, symSize: 0x160 }
-  - { offsetInCU: 0x4DF, offset: 0x84A7C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC7getFile33_F00B23A4165DD6ABFCD23C8811C7DF43LLyS2SKFZTf4nd_g', symObjAddr: 0x848, symBinAddr: 0x14418, symSize: 0x2E4 }
-  - { offsetInCU: 0x5AE, offset: 0x84B4B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCMa', symObjAddr: 0xB2C, symBinAddr: 0x146FC, symSize: 0x20 }
-  - { offsetInCU: 0x5C2, offset: 0x84B5F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOAEs5ErrorAAWl', symObjAddr: 0xB4C, symBinAddr: 0x1471C, symSize: 0x44 }
-  - { offsetInCU: 0x5D6, offset: 0x84B73, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwCP', symObjAddr: 0xB90, symBinAddr: 0x14760, symSize: 0x2C }
-  - { offsetInCU: 0x5EA, offset: 0x84B87, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwxx', symObjAddr: 0xBBC, symBinAddr: 0x1478C, symSize: 0x8 }
-  - { offsetInCU: 0x5FE, offset: 0x84B9B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwca', symObjAddr: 0xBC4, symBinAddr: 0x14794, symSize: 0x40 }
-  - { offsetInCU: 0x612, offset: 0x84BAF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwta', symObjAddr: 0xC10, symBinAddr: 0x147D4, symSize: 0x30 }
-  - { offsetInCU: 0x626, offset: 0x84BC3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwet', symObjAddr: 0xC40, symBinAddr: 0x14804, symSize: 0x48 }
-  - { offsetInCU: 0x63A, offset: 0x84BD7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwst', symObjAddr: 0xC88, symBinAddr: 0x1484C, symSize: 0x3C }
-  - { offsetInCU: 0x64E, offset: 0x84BEB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwug', symObjAddr: 0xCC4, symBinAddr: 0x14888, symSize: 0x8 }
-  - { offsetInCU: 0x662, offset: 0x84BFF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwup', symObjAddr: 0xCCC, symBinAddr: 0x14890, symSize: 0x4 }
-  - { offsetInCU: 0x676, offset: 0x84C13, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwui', symObjAddr: 0xCD0, symBinAddr: 0x14894, symSize: 0x4 }
-  - { offsetInCU: 0x68A, offset: 0x84C27, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOMa', symObjAddr: 0xCD4, symBinAddr: 0x14898, symSize: 0x10 }
-  - { offsetInCU: 0x712, offset: 0x84CAF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP7_domainSSvgTW', symObjAddr: 0x3D8, symBinAddr: 0x13FA8, symSize: 0x4 }
-  - { offsetInCU: 0x72E, offset: 0x84CCB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP5_codeSivgTW', symObjAddr: 0x3DC, symBinAddr: 0x13FAC, symSize: 0x4 }
-  - { offsetInCU: 0x74A, offset: 0x84CE7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP9_userInfoyXlSgvgTW', symObjAddr: 0x3E0, symBinAddr: 0x13FB0, symSize: 0x4 }
-  - { offsetInCU: 0x766, offset: 0x84D03, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP19_getEmbeddedNSErroryXlSgyFTW', symObjAddr: 0x3E4, symBinAddr: 0x13FB4, symSize: 0x4 }
-  - { offsetInCU: 0xA14, offset: 0x84FB1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC18createTextureCacheSo017CVOpenGLESTextureF3RefaSgyFZ', symObjAddr: 0x0, symBinAddr: 0x13BD0, symSize: 0xA4 }
-  - { offsetInCU: 0xAAA, offset: 0x85047, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11createImageySo11CVBufferRefaSgSo022CVOpenGLESTextureCacheG0a_AFSo012CFDictionaryG0aSgs6UInt32Vs5Int32VA2p2NSitFZ', symObjAddr: 0x148, symBinAddr: 0x13D18, symSize: 0x90 }
-  - { offsetInCU: 0xC31, offset: 0x851CE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11setupRenderAA9NSCRenderCyFZ', symObjAddr: 0x2E8, symBinAddr: 0x13EB8, symSize: 0x24 }
-  - { offsetInCU: 0xC7B, offset: 0x85218, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC9drawFrameyySo8AVPlayerC_So0F15ItemVideoOutputCSo6CGSizeVAA9NSCRenderCs5Int32VANSbtFZ', symObjAddr: 0x334, symBinAddr: 0x13F04, symSize: 0x4 }
-  - { offsetInCU: 0xC9D, offset: 0x8523A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11writeToFileyySo6NSDataC_SStKFZ', symObjAddr: 0x3E8, symBinAddr: 0x13FB8, symSize: 0xE8 }
-  - { offsetInCU: 0xD4D, offset: 0x852EA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCACycfC', symObjAddr: 0x62C, symBinAddr: 0x141FC, symSize: 0x20 }
-  - { offsetInCU: 0xD61, offset: 0x852FE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCACycfc', symObjAddr: 0x64C, symBinAddr: 0x1421C, symSize: 0x30 }
-  - { offsetInCU: 0xD97, offset: 0x85334, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCfD', symObjAddr: 0x6B8, symBinAddr: 0x14288, symSize: 0x30 }
-  - { offsetInCU: 0x27, offset: 0x8544D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x0, symBinAddr: 0x148AC, symSize: 0x4 }
-  - { offsetInCU: 0x71, offset: 0x85497, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZTo', symObjAddr: 0x4, symBinAddr: 0x148B0, symSize: 0x70 }
-  - { offsetInCU: 0xF6, offset: 0x8551C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS2ftFZTo', symObjAddr: 0x78, symBinAddr: 0x14924, symSize: 0x50 }
-  - { offsetInCU: 0x191, offset: 0x855B7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS4ftFZTo', symObjAddr: 0xCC, symBinAddr: 0x14978, symSize: 0x68 }
-  - { offsetInCU: 0x254, offset: 0x8567A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS8ftFZTo', symObjAddr: 0x138, symBinAddr: 0x149E4, symSize: 0x98 }
-  - { offsetInCU: 0x323, offset: 0x85749, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCACycfcTo', symObjAddr: 0x220, symBinAddr: 0x14ACC, symSize: 0x3C }
-  - { offsetInCU: 0x375, offset: 0x8579B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCMa', symObjAddr: 0x28C, symBinAddr: 0x14B38, symSize: 0x20 }
-  - { offsetInCU: 0x4E5, offset: 0x8590B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x0, symBinAddr: 0x148AC, symSize: 0x4 }
-  - { offsetInCU: 0x51D, offset: 0x85943, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x0, symBinAddr: 0x148AC, symSize: 0x4 }
-  - { offsetInCU: 0x588, offset: 0x859AE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS2ftFZ', symObjAddr: 0x74, symBinAddr: 0x14920, symSize: 0x4 }
-  - { offsetInCU: 0x5C8, offset: 0x859EE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS2ftFZ', symObjAddr: 0x74, symBinAddr: 0x14920, symSize: 0x4 }
-  - { offsetInCU: 0x62A, offset: 0x85A50, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS4ftFZ', symObjAddr: 0xC8, symBinAddr: 0x14974, symSize: 0x4 }
-  - { offsetInCU: 0x67C, offset: 0x85AA2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS4ftFZ', symObjAddr: 0xC8, symBinAddr: 0x14974, symSize: 0x4 }
-  - { offsetInCU: 0x6F1, offset: 0x85B17, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS8ftFZ', symObjAddr: 0x134, symBinAddr: 0x149E0, symSize: 0x4 }
-  - { offsetInCU: 0x767, offset: 0x85B8D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS8ftFZ', symObjAddr: 0x134, symBinAddr: 0x149E0, symSize: 0x4 }
-  - { offsetInCU: 0x805, offset: 0x85C2B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCACycfC', symObjAddr: 0x1D0, symBinAddr: 0x14A7C, symSize: 0x20 }
-  - { offsetInCU: 0x819, offset: 0x85C3F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCACycfc', symObjAddr: 0x1F0, symBinAddr: 0x14A9C, symSize: 0x30 }
-  - { offsetInCU: 0x84F, offset: 0x85C75, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCfD', symObjAddr: 0x25C, symBinAddr: 0x14B08, symSize: 0x30 }
-  - { offsetInCU: 0x27, offset: 0x85CBF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC10texImage2Dyys5Int64V_s5Int32VA4HSpys5UInt8VGSuSo6CGSizeVSbtFZ', symObjAddr: 0x0, symBinAddr: 0x14B58, symSize: 0x14 }
-  - { offsetInCU: 0xA9, offset: 0x85D41, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC10texImage2Dyys5Int64V_s5Int32VA4HSpys5UInt8VGSuSo6CGSizeVSbtFZTo', symObjAddr: 0x14, symBinAddr: 0x14B6C, symSize: 0x38 }
-  - { offsetInCU: 0x1A2, offset: 0x85E3A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC13texSubImage2Dyys5Int64V_s5Int32VA5HSpys5UInt8VGSuSo6CGSizeVSbtFZTo', symObjAddr: 0x68, symBinAddr: 0x14BC0, symSize: 0x40 }
-  - { offsetInCU: 0x284, offset: 0x85F1C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCACycfcTo', symObjAddr: 0x118, symBinAddr: 0x14C70, symSize: 0x3C }
-  - { offsetInCU: 0x2D6, offset: 0x85F6E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCMa', symObjAddr: 0xF8, symBinAddr: 0x14C50, symSize: 0x20 }
-  - { offsetInCU: 0x480, offset: 0x86118, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC10texImage2Dyys5Int64V_s5Int32VA4HSpys5UInt8VGSuSo6CGSizeVSbtFZ', symObjAddr: 0x0, symBinAddr: 0x14B58, symSize: 0x14 }
-  - { offsetInCU: 0x5C4, offset: 0x8625C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC13texSubImage2Dyys5Int64V_s5Int32VA5HSpys5UInt8VGSuSo6CGSizeVSbtFZ', symObjAddr: 0x4C, symBinAddr: 0x14BA4, symSize: 0x1C }
-  - { offsetInCU: 0x6FA, offset: 0x86392, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCACycfC', symObjAddr: 0xA8, symBinAddr: 0x14C00, symSize: 0x20 }
-  - { offsetInCU: 0x70E, offset: 0x863A6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCACycfc', symObjAddr: 0xC8, symBinAddr: 0x14C20, symSize: 0x30 }
-  - { offsetInCU: 0x744, offset: 0x863DC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCfD', symObjAddr: 0x154, symBinAddr: 0x14CAC, symSize: 0x30 }
-  - { offsetInCU: 0x61, offset: 0x86460, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7isDirtySbvgTo', symObjAddr: 0x4, symBinAddr: 0x14CE0, symSize: 0x10 }
-  - { offsetInCU: 0x81, offset: 0x86480, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7isDirtySbvgTo', symObjAddr: 0x4, symBinAddr: 0x14CE0, symSize: 0x10 }
-  - { offsetInCU: 0xB7, offset: 0x864B6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7isDirtySbvsTo', symObjAddr: 0x14, symBinAddr: 0x14CF0, symSize: 0x10 }
-  - { offsetInCU: 0xD7, offset: 0x864D6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7isDirtySbvsTo', symObjAddr: 0x14, symBinAddr: 0x14CF0, symSize: 0x10 }
-  - { offsetInCU: 0x110, offset: 0x8650F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC6canvasAA9NSCCanvasCSgvgTo', symObjAddr: 0x24, symBinAddr: 0x14D00, symSize: 0x48 }
-  - { offsetInCU: 0x168, offset: 0x86567, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC6canvasAA9NSCCanvasCSgvsTo', symObjAddr: 0xB4, symBinAddr: 0x14D90, symSize: 0x50 }
-  - { offsetInCU: 0x1C3, offset: 0x865C2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC3fbos6UInt32VvgTo', symObjAddr: 0x104, symBinAddr: 0x14DE0, symSize: 0x10 }
-  - { offsetInCU: 0x1E3, offset: 0x865E2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC3fbos6UInt32VvgTo', symObjAddr: 0x104, symBinAddr: 0x14DE0, symSize: 0x10 }
-  - { offsetInCU: 0x219, offset: 0x86618, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC3fbos6UInt32VvsTo', symObjAddr: 0x114, symBinAddr: 0x14DF0, symSize: 0x10 }
-  - { offsetInCU: 0x239, offset: 0x86638, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC3fbos6UInt32VvsTo', symObjAddr: 0x114, symBinAddr: 0x14DF0, symSize: 0x10 }
-  - { offsetInCU: 0x272, offset: 0x86671, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCACycfcTo', symObjAddr: 0x1B0, symBinAddr: 0x14E8C, symSize: 0x78 }
-  - { offsetInCU: 0x2C8, offset: 0x866C7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frameACSo6CGRectV_tcfcTo', symObjAddr: 0x2D4, symBinAddr: 0x14FB0, symSize: 0xB0 }
-  - { offsetInCU: 0x32A, offset: 0x86729, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5coderACSgSo7NSCoderC_tcfcTo', symObjAddr: 0x43C, symBinAddr: 0x15118, symSize: 0x28 }
-  - { offsetInCU: 0x35C, offset: 0x8675B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC12bindDrawableyyFTo', symObjAddr: 0x4E0, symBinAddr: 0x15140, symSize: 0xA0 }
-  - { offsetInCU: 0x3DD, offset: 0x867DC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC14deleteDrawableyyFTo', symObjAddr: 0x5BC, symBinAddr: 0x151E0, symSize: 0x60 }
-  - { offsetInCU: 0x44D, offset: 0x8684C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7glkView_6drawInySo0C0C_So6CGRectVtFTo', symObjAddr: 0x620, symBinAddr: 0x15244, symSize: 0x4C }
-  - { offsetInCU: 0x4BF, offset: 0x868BE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frame7contextACSo6CGRectV_So11EAGLContextCtcfcTo', symObjAddr: 0x70C, symBinAddr: 0x15330, symSize: 0x34 }
-  - { offsetInCU: 0x533, offset: 0x86932, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCMa', symObjAddr: 0x190, symBinAddr: 0x14E6C, symSize: 0x20 }
-  - { offsetInCU: 0x55D, offset: 0x8695C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCfETo', symObjAddr: 0x74C, symBinAddr: 0x15370, symSize: 0x10 }
-  - { offsetInCU: 0x65B, offset: 0x86A5A, size: 0x8, addend: 0x0, symName: '_$sSo7GLKViewC12CanvasNativeE16snapshotWithDatayy10Foundation0F0VFTo', symObjAddr: 0xA08, symBinAddr: 0x1562C, symSize: 0x74 }
-  - { offsetInCU: 0x699, offset: 0x86A98, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC7isDirtySbvgTo', symObjAddr: 0xA7C, symBinAddr: 0x156A0, symSize: 0x10 }
-  - { offsetInCU: 0x6B9, offset: 0x86AB8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC7isDirtySbvgTo', symObjAddr: 0xA7C, symBinAddr: 0x156A0, symSize: 0x10 }
-  - { offsetInCU: 0x6EF, offset: 0x86AEE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC7isDirtySbvsTo', symObjAddr: 0xA8C, symBinAddr: 0x156B0, symSize: 0x10 }
-  - { offsetInCU: 0x70F, offset: 0x86B0E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC7isDirtySbvsTo', symObjAddr: 0xA8C, symBinAddr: 0x156B0, symSize: 0x10 }
-  - { offsetInCU: 0x748, offset: 0x86B47, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC8rendererAA9NSCCanvasCSgvgTo', symObjAddr: 0xA9C, symBinAddr: 0x156C0, symSize: 0x20 }
-  - { offsetInCU: 0x7A0, offset: 0x86B9F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC8rendererAA9NSCCanvasCSgvsTo', symObjAddr: 0xABC, symBinAddr: 0x156E0, symSize: 0x14 }
-  - { offsetInCU: 0x7FB, offset: 0x86BFA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvgTo', symObjAddr: 0xAD0, symBinAddr: 0x156F4, symSize: 0x44 }
-  - { offsetInCU: 0x853, offset: 0x86C52, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvsTo', symObjAddr: 0xB58, symBinAddr: 0x1577C, symSize: 0x48 }
-  - { offsetInCU: 0x8E8, offset: 0x86CE7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCACycfcTo', symObjAddr: 0xCBC, symBinAddr: 0x158E0, symSize: 0x78 }
-  - { offsetInCU: 0x93E, offset: 0x86D3D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5frameACSo6CGRectV_tcfcTo', symObjAddr: 0xE34, symBinAddr: 0x15A58, symSize: 0xB0 }
-  - { offsetInCU: 0x9A0, offset: 0x86D9F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5coderACSgSo7NSCoderC_tcfcTo', symObjAddr: 0xF90, symBinAddr: 0x15BB4, symSize: 0x28 }
-  - { offsetInCU: 0x9D2, offset: 0x86DD1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC11deviceScaleSfyFTo', symObjAddr: 0xFB8, symBinAddr: 0x15BDC, symSize: 0xB8 }
-  - { offsetInCU: 0xA53, offset: 0x86E52, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC4drawyySo6CGRectVFTo', symObjAddr: 0x1074, symBinAddr: 0x15C94, symSize: 0x28 }
-  - { offsetInCU: 0xAB1, offset: 0x86EB0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCfETo', symObjAddr: 0x10D8, symBinAddr: 0x15CF8, symSize: 0x10 }
-  - { offsetInCU: 0xC63, offset: 0x87062, size: 0x8, addend: 0x0, symName: '_$ss22_ContiguousArrayBufferV19_uninitializedCount15minimumCapacityAByxGSi_SitcfC12CanvasNative15NSCTouchHandlerC7PointerV_Tgm5', symObjAddr: 0x130C, symBinAddr: 0x15E78, symSize: 0x80 }
-  - { offsetInCU: 0xCE6, offset: 0x870E5, size: 0x8, addend: 0x0, symName: '_$ss22_ContiguousArrayBufferV19_uninitializedCount15minimumCapacityAByxGSi_SitcfCs5UInt8V_Tgm5', symObjAddr: 0x140C, symBinAddr: 0x15EF8, symSize: 0x6C }
-  - { offsetInCU: 0xD6A, offset: 0x87169, size: 0x8, addend: 0x0, symName: '_$s10Foundation4DataV15_RepresentationOWOy', symObjAddr: 0x1630, symBinAddr: 0x1611C, symSize: 0x44 }
-  - { offsetInCU: 0xD7E, offset: 0x8717D, size: 0x8, addend: 0x0, symName: '_$s10Foundation4DataV15_RepresentationOWOe', symObjAddr: 0x1674, symBinAddr: 0x16160, symSize: 0x44 }
-  - { offsetInCU: 0xD92, offset: 0x87191, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCMa', symObjAddr: 0x16B8, symBinAddr: 0x161A4, symSize: 0x20 }
-  - { offsetInCU: 0xE6C, offset: 0x8726B, size: 0x8, addend: 0x0, symName: '_$sSaySayxGqd__c7ElementQyd__RszSTRd__lufCs5UInt8V_10Foundation4DataVTgm5Tf4g_n', symObjAddr: 0x14FC, symBinAddr: 0x15FE8, symSize: 0x124 }
-  - { offsetInCU: 0x112B, offset: 0x8752A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC6canvasAA9NSCCanvasCSgvg', symObjAddr: 0x6C, symBinAddr: 0x14D48, symSize: 0x48 }
-  - { offsetInCU: 0x11A8, offset: 0x875A7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCACycfc', symObjAddr: 0x124, symBinAddr: 0x14E00, symSize: 0x6C }
-  - { offsetInCU: 0x11EF, offset: 0x875EE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frameACSo6CGRectV_tcfc', symObjAddr: 0x228, symBinAddr: 0x14F04, symSize: 0xAC }
-  - { offsetInCU: 0x1253, offset: 0x87652, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5coderACSgSo7NSCoderC_tcfc', symObjAddr: 0x384, symBinAddr: 0x15060, symSize: 0xB8 }
-  - { offsetInCU: 0x12DE, offset: 0x876DD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7glkView_6drawInySo0C0C_So6CGRectVtF', symObjAddr: 0x61C, symBinAddr: 0x15240, symSize: 0x4 }
-  - { offsetInCU: 0x12FF, offset: 0x876FE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frame7contextACSo6CGRectV_So11EAGLContextCtcfC', symObjAddr: 0x66C, symBinAddr: 0x15290, symSize: 0x74 }
-  - { offsetInCU: 0x1313, offset: 0x87712, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frame7contextACSo6CGRectV_So11EAGLContextCtcfc', symObjAddr: 0x6E0, symBinAddr: 0x15304, symSize: 0x2C }
-  - { offsetInCU: 0x142C, offset: 0x8782B, size: 0x8, addend: 0x0, symName: '_$sSo7GLKViewC12CanvasNativeE16snapshotWithDatayy10Foundation0F0VF', symObjAddr: 0x75C, symBinAddr: 0x15380, symSize: 0x2AC }
-  - { offsetInCU: 0x17D6, offset: 0x87BD5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvg', symObjAddr: 0xB14, symBinAddr: 0x15738, symSize: 0x44 }
-  - { offsetInCU: 0x1815, offset: 0x87C14, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvs', symObjAddr: 0xBA0, symBinAddr: 0x157C4, symSize: 0x48 }
-  - { offsetInCU: 0x183A, offset: 0x87C39, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvM', symObjAddr: 0xBE8, symBinAddr: 0x1580C, symSize: 0x44 }
-  - { offsetInCU: 0x185F, offset: 0x87C5E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvM.resume.0', symObjAddr: 0xC2C, symBinAddr: 0x15850, symSize: 0x4 }
-  - { offsetInCU: 0x1886, offset: 0x87C85, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCACycfC', symObjAddr: 0xC30, symBinAddr: 0x15854, symSize: 0x20 }
-  - { offsetInCU: 0x189A, offset: 0x87C99, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCACycfc', symObjAddr: 0xC50, symBinAddr: 0x15874, symSize: 0x6C }
-  - { offsetInCU: 0x18E1, offset: 0x87CE0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5frameACSo6CGRectV_tcfc', symObjAddr: 0xD88, symBinAddr: 0x159AC, symSize: 0xAC }
-  - { offsetInCU: 0x1940, offset: 0x87D3F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5coderACSgSo7NSCoderC_tcfc', symObjAddr: 0xEE4, symBinAddr: 0x15B08, symSize: 0xAC }
-  - { offsetInCU: 0x19DE, offset: 0x87DDD, size: 0x8, addend: 0x0, symName: '_$ss12_ArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtF12CanvasNative15NSCTouchHandlerC7PointerV_Tg5', symObjAddr: 0x10E8, symBinAddr: 0x15D08, symSize: 0xBC }
-  - { offsetInCU: 0x1AC0, offset: 0x87EBF, size: 0x8, addend: 0x0, symName: '_$ss12_ArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtFs5UInt8V_Tg5', symObjAddr: 0x1258, symBinAddr: 0x15DC4, symSize: 0xB4 }
-  - { offsetInCU: 0x1BCC, offset: 0x87FCB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7glkView_6drawInySo0C0C_So6CGRectVtFTf4ddn_n', symObjAddr: 0x1478, symBinAddr: 0x15F64, symSize: 0x84 }
-  - { offsetInCU: 0x1CC5, offset: 0x880C4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC4drawyySo6CGRectVFTf4dn_n', symObjAddr: 0x16D8, symBinAddr: 0x161C4, symSize: 0x360 }
-  - { offsetInCU: 0x4F, offset: 0x88502, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC5queue33_7ED578B0ED4B2B6F6887A622A7B49AA3LLSo012OS_dispatch_E0CvpZ', symObjAddr: 0x980, symBinAddr: 0x10D3E50, symSize: 0x0 }
-  - { offsetInCU: 0x5D, offset: 0x88510, size: 0x8, addend: 0x0, symName: '_$sIegh_IeyBh_TR', symObjAddr: 0x0, symBinAddr: 0x16710, symSize: 0x2C }
-  - { offsetInCU: 0x75, offset: 0x88528, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC5queue33_7ED578B0ED4B2B6F6887A622A7B49AA3LL_WZ', symObjAddr: 0x2C, symBinAddr: 0x1673C, symSize: 0x10C }
-  - { offsetInCU: 0xBC, offset: 0x8856F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF4SyncySbs5Int64V_So7UIImageCtFZTo', symObjAddr: 0x13C, symBinAddr: 0x1684C, symSize: 0x44 }
-  - { offsetInCU: 0x132, offset: 0x885E5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZTo', symObjAddr: 0x3E4, symBinAddr: 0x16AF4, symSize: 0x80 }
-  - { offsetInCU: 0x191, offset: 0x88644, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCACycfcTo', symObjAddr: 0x4B4, symBinAddr: 0x16BC4, symSize: 0x3C }
-  - { offsetInCU: 0x1E2, offset: 0x88695, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZTf4nnnd_n', symObjAddr: 0x524, symBinAddr: 0x16C34, symSize: 0x214 }
-  - { offsetInCU: 0x261, offset: 0x88714, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCfETo', symObjAddr: 0x520, symBinAddr: 0x16C30, symSize: 0x4 }
-  - { offsetInCU: 0x29D, offset: 0x88750, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCMa', symObjAddr: 0x738, symBinAddr: 0x16E48, symSize: 0x20 }
-  - { offsetInCU: 0x2BC, offset: 0x8876F, size: 0x8, addend: 0x0, symName: '_$s10ObjectiveC8ObjCBoolVIeyBy_SbIegy_TRTA', symObjAddr: 0x77C, symBinAddr: 0x16E8C, symSize: 0x14 }
-  - { offsetInCU: 0x2E5, offset: 0x88798, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_TA', symObjAddr: 0x7BC, symBinAddr: 0x16ECC, symSize: 0xC }
-  - { offsetInCU: 0x2F9, offset: 0x887AC, size: 0x8, addend: 0x0, symName: _block_copy_helper, symObjAddr: 0x7C8, symBinAddr: 0x16ED8, symSize: 0x10 }
-  - { offsetInCU: 0x30D, offset: 0x887C0, size: 0x8, addend: 0x0, symName: _block_destroy_helper, symObjAddr: 0x7D8, symBinAddr: 0x16EE8, symSize: 0x8 }
-  - { offsetInCU: 0x321, offset: 0x887D4, size: 0x8, addend: 0x0, symName: '_$sSay8Dispatch0A13WorkItemFlagsVGMa', symObjAddr: 0x860, symBinAddr: 0x16F30, symSize: 0x54 }
-  - { offsetInCU: 0x335, offset: 0x887E8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_yyScMYccfU0_TA', symObjAddr: 0x8F0, symBinAddr: 0x16F84, symSize: 0x24 }
-  - { offsetInCU: 0x369, offset: 0x8881C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_yyScMYccfU_TA', symObjAddr: 0x938, symBinAddr: 0x16FCC, symSize: 0x24 }
-  - { offsetInCU: 0x4FE, offset: 0x889B1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF4SyncySbs5Int64V_So7UIImageCtFZ', symObjAddr: 0x138, symBinAddr: 0x16848, symSize: 0x4 }
-  - { offsetInCU: 0x52C, offset: 0x889DF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF4SyncySbs5Int64V_So7UIImageCtFZ', symObjAddr: 0x138, symBinAddr: 0x16848, symSize: 0x4 }
-  - { offsetInCU: 0x58B, offset: 0x88A3E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZ', symObjAddr: 0x180, symBinAddr: 0x16890, symSize: 0x4 }
-  - { offsetInCU: 0x59F, offset: 0x88A52, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_', symObjAddr: 0x184, symBinAddr: 0x16894, symSize: 0x260 }
-  - { offsetInCU: 0x678, offset: 0x88B2B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCACycfC', symObjAddr: 0x464, symBinAddr: 0x16B74, symSize: 0x20 }
-  - { offsetInCU: 0x68C, offset: 0x88B3F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCACycfc', symObjAddr: 0x484, symBinAddr: 0x16B94, symSize: 0x30 }
-  - { offsetInCU: 0x6C2, offset: 0x88B75, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCfD', symObjAddr: 0x4F0, symBinAddr: 0x16C00, symSize: 0x30 }
-  - { offsetInCU: 0x27, offset: 0x88C1B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfC', symObjAddr: 0x0, symBinAddr: 0x17004, symSize: 0x20 }
-  - { offsetInCU: 0x77, offset: 0x88C6B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfcTo', symObjAddr: 0x70, symBinAddr: 0x17074, symSize: 0x3C }
-  - { offsetInCU: 0xC9, offset: 0x88CBD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCMa', symObjAddr: 0x50, symBinAddr: 0x17054, symSize: 0x20 }
-  - { offsetInCU: 0x214, offset: 0x88E08, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfC', symObjAddr: 0x0, symBinAddr: 0x17004, symSize: 0x20 }
-  - { offsetInCU: 0x228, offset: 0x88E1C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfc', symObjAddr: 0x20, symBinAddr: 0x17024, symSize: 0x30 }
-  - { offsetInCU: 0x264, offset: 0x88E58, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCfD', symObjAddr: 0xAC, symBinAddr: 0x170B0, symSize: 0x30 }
-  - { offsetInCU: 0x26, offset: 0x88EA1, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_frombytes_vartime, symObjAddr: 0x0, symBinAddr: 0x2B8E40, symSize: 0x265C }
-  - { offsetInCU: 0x40, offset: 0x88EBB, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_k25519Precomp, symObjAddr: 0x9DE0, symBinAddr: 0x9A41C0, symSize: 0x0 }
-  - { offsetInCU: 0x92, offset: 0x88F0D, size: 0x8, addend: 0x0, symName: _d, symObjAddr: 0xFDE0, symBinAddr: 0x9AA1C0, symSize: 0x0 }
-  - { offsetInCU: 0xF6, offset: 0x88F71, size: 0x8, addend: 0x0, symName: _sqrtm1, symObjAddr: 0xFE08, symBinAddr: 0x9AA1E8, symSize: 0x0 }
-  - { offsetInCU: 0x10C, offset: 0x88F87, size: 0x8, addend: 0x0, symName: _d2, symObjAddr: 0x10210, symBinAddr: 0x9AA5F0, symSize: 0x0 }
-  - { offsetInCU: 0x123, offset: 0x88F9E, size: 0x8, addend: 0x0, symName: _Bi, symObjAddr: 0xFE50, symBinAddr: 0x9AA230, symSize: 0x0 }
-  - { offsetInCU: 0x9C2, offset: 0x8983D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_frombytes_vartime, symObjAddr: 0x0, symBinAddr: 0x2B8E40, symSize: 0x265C }
-  - { offsetInCU: 0x45CD, offset: 0x8D448, size: 0x8, addend: 0x0, symName: _fe_frombytes, symObjAddr: 0x265C, symBinAddr: 0x2BB49C, symSize: 0x134 }
-  - { offsetInCU: 0x46F3, offset: 0x8D56E, size: 0x8, addend: 0x0, symName: _fe_mul_impl, symObjAddr: 0x9918, symBinAddr: 0x2C2758, symSize: 0x21C }
-  - { offsetInCU: 0x4922, offset: 0x8D79D, size: 0x8, addend: 0x0, symName: _fe_tobytes, symObjAddr: 0x4FDC, symBinAddr: 0x2BDE1C, symSize: 0x1B8 }
-  - { offsetInCU: 0x530F, offset: 0x8E18A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_scalarmult_base, symObjAddr: 0x2790, symBinAddr: 0x2BB5D0, symSize: 0x5BC }
-  - { offsetInCU: 0x5F72, offset: 0x8EDED, size: 0x8, addend: 0x0, symName: _table_select, symObjAddr: 0x2D4C, symBinAddr: 0x2BBB8C, symSize: 0x7F8 }
-  - { offsetInCU: 0x642A, offset: 0x8F2A5, size: 0x8, addend: 0x0, symName: _ge_madd, symObjAddr: 0x3544, symBinAddr: 0x2BC384, symSize: 0x208 }
-  - { offsetInCU: 0x69F8, offset: 0x8F873, size: 0x8, addend: 0x0, symName: _ge_p2_dbl, symObjAddr: 0x374C, symBinAddr: 0x2BC58C, symSize: 0x7B0 }
-  - { offsetInCU: 0x77D8, offset: 0x90653, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_sc_reduce, symObjAddr: 0x3EFC, symBinAddr: 0x2BCD3C, symSize: 0x634 }
-  - { offsetInCU: 0x8199, offset: 0x91014, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_scalar_mult_generic_masked, symObjAddr: 0x4530, symBinAddr: 0x2BD370, symSize: 0xAAC }
-  - { offsetInCU: 0x956A, offset: 0x923E5, size: 0x8, addend: 0x0, symName: _fe_loose_invert, symObjAddr: 0x5298, symBinAddr: 0x2BE0D8, symSize: 0x23F8 }
-  - { offsetInCU: 0xCABB, offset: 0x95936, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_public_from_private_generic_masked, symObjAddr: 0x5194, symBinAddr: 0x2BDFD4, symSize: 0x104 }
-  - { offsetInCU: 0xCD03, offset: 0x95B7E, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_invert, symObjAddr: 0x7690, symBinAddr: 0x2C04D0, symSize: 0x30 }
-  - { offsetInCU: 0xCDF4, offset: 0x95C6F, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_isnegative, symObjAddr: 0x76C0, symBinAddr: 0x2C0500, symSize: 0x58 }
-  - { offsetInCU: 0xCE69, offset: 0x95CE4, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_mul_ttt, symObjAddr: 0x7718, symBinAddr: 0x2C0558, symSize: 0x4 }
-  - { offsetInCU: 0xCEB1, offset: 0x95D2C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_mul_ttt, symObjAddr: 0x7718, symBinAddr: 0x2C0558, symSize: 0x4 }
-  - { offsetInCU: 0xCEE0, offset: 0x95D5B, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_mul_ttt, symObjAddr: 0x7718, symBinAddr: 0x2C0558, symSize: 0x4 }
-  - { offsetInCU: 0xCF04, offset: 0x95D7F, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_neg, symObjAddr: 0x771C, symBinAddr: 0x2C055C, symSize: 0x8C }
-  - { offsetInCU: 0xD039, offset: 0x95EB4, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_tobytes, symObjAddr: 0x77A8, symBinAddr: 0x2C05E8, symSize: 0x4 }
-  - { offsetInCU: 0xD072, offset: 0x95EED, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_tobytes, symObjAddr: 0x77A8, symBinAddr: 0x2C05E8, symSize: 0x4 }
-  - { offsetInCU: 0xD30B, offset: 0x96186, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_double_scalarmult_vartime, symObjAddr: 0x77AC, symBinAddr: 0x2C05EC, symSize: 0x1598 }
-  - { offsetInCU: 0x10654, offset: 0x994CF, size: 0x8, addend: 0x0, symName: _x25519_ge_add, symObjAddr: 0x9B34, symBinAddr: 0x2C2974, symSize: 0x218 }
-  - { offsetInCU: 0x10C86, offset: 0x99B01, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_sc_mask, symObjAddr: 0x8D44, symBinAddr: 0x2C1B84, symSize: 0x20 }
-  - { offsetInCU: 0x11123, offset: 0x99F9E, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_sc_muladd, symObjAddr: 0x8D64, symBinAddr: 0x2C1BA4, symSize: 0xBB4 }
-  - { offsetInCU: 0x26, offset: 0x9AD81, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_from_montgomery_in_place, symObjAddr: 0x0, symBinAddr: 0x2C2B8C, symSize: 0x1F4 }
-  - { offsetInCU: 0x1D2, offset: 0x9AF2D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_from_montgomery_in_place, symObjAddr: 0x0, symBinAddr: 0x2C2B8C, symSize: 0x1F4 }
-  - { offsetInCU: 0x26, offset: 0x9B1C8, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_neg_inv_mod_r_u64, symObjAddr: 0x0, symBinAddr: 0x2C2D80, symSize: 0x3C }
-  - { offsetInCU: 0x34, offset: 0x9B1D6, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_neg_inv_mod_r_u64, symObjAddr: 0x0, symBinAddr: 0x2C2D80, symSize: 0x3C }
-  - { offsetInCU: 0x26, offset: 0x9B2E6, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_little_endian_bytes_from_scalar, symObjAddr: 0x0, symBinAddr: 0x2C2DBC, symSize: 0x98 }
-  - { offsetInCU: 0x34, offset: 0x9B2F4, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_little_endian_bytes_from_scalar, symObjAddr: 0x0, symBinAddr: 0x2C2DBC, symSize: 0x98 }
-  - { offsetInCU: 0x86, offset: 0x9B457, size: 0x8, addend: 0x0, symName: _Q_N0, symObjAddr: 0x1100, symBinAddr: 0x9AA6A0, symSize: 0x0 }
-  - { offsetInCU: 0xB8, offset: 0x9B489, size: 0x8, addend: 0x0, symName: _Q, symObjAddr: 0x1090, symBinAddr: 0x9AA630, symSize: 0x0 }
-  - { offsetInCU: 0xDA, offset: 0x9B4AB, size: 0x8, addend: 0x0, symName: _N, symObjAddr: 0x10C0, symBinAddr: 0x9AA660, symSize: 0x0 }
-  - { offsetInCU: 0xF0, offset: 0x9B4C1, size: 0x8, addend: 0x0, symName: _N_N0, symObjAddr: 0x10F0, symBinAddr: 0x9AA690, symSize: 0x0 }
-  - { offsetInCU: 0x3B7, offset: 0x9B788, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_elem_mul_mont, symObjAddr: 0x100, symBinAddr: 0x2C2E54, symSize: 0x18 }
-  - { offsetInCU: 0x3FB, offset: 0x9B7CC, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_elem_mul_mont, symObjAddr: 0x100, symBinAddr: 0x2C2E54, symSize: 0x18 }
-  - { offsetInCU: 0x594, offset: 0x9B965, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_scalar_mul_mont, symObjAddr: 0x1F8, symBinAddr: 0x2C2E6C, symSize: 0x18 }
-  - { offsetInCU: 0x63F, offset: 0x9BA10, size: 0x8, addend: 0x0, symName: _nistz384_point_double, symObjAddr: 0x290, symBinAddr: 0x2C2E84, symSize: 0x320 }
-  - { offsetInCU: 0x1199, offset: 0x9C56A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_point_add, symObjAddr: 0x5B0, symBinAddr: 0x2C31A4, symSize: 0xAC }
-  - { offsetInCU: 0x148F, offset: 0x9C860, size: 0x8, addend: 0x0, symName: _nistz384_point_add, symObjAddr: 0x65C, symBinAddr: 0x2C3250, symSize: 0x500 }
-  - { offsetInCU: 0x268C, offset: 0x9DA5D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_point_mul, symObjAddr: 0xB5C, symBinAddr: 0x2C3750, symSize: 0x2C8 }
-  - { offsetInCU: 0x2CDB, offset: 0x9E0AC, size: 0x8, addend: 0x0, symName: _p384_point_select_w5, symObjAddr: 0xE24, symBinAddr: 0x2C3A18, symSize: 0xF4 }
-  - { offsetInCU: 0x2EED, offset: 0x9E2BE, size: 0x8, addend: 0x0, symName: _add_precomputed_w5, symObjAddr: 0xF18, symBinAddr: 0x2C3B0C, symSize: 0x168 }
-  - { offsetInCU: 0x26, offset: 0x9E623, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_zero, symObjAddr: 0x0, symBinAddr: 0x2C3C74, symSize: 0x38 }
-  - { offsetInCU: 0xFA, offset: 0x9E6F7, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_zero, symObjAddr: 0x0, symBinAddr: 0x2C3C74, symSize: 0x38 }
-  - { offsetInCU: 0x12C, offset: 0x9E729, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_zero, symObjAddr: 0x0, symBinAddr: 0x2C3C74, symSize: 0x38 }
-  - { offsetInCU: 0x199, offset: 0x9E796, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_equal, symObjAddr: 0x38, symBinAddr: 0x2C3CAC, symSize: 0x3C }
-  - { offsetInCU: 0x1F3, offset: 0x9E7F0, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_equal, symObjAddr: 0x38, symBinAddr: 0x2C3CAC, symSize: 0x3C }
-  - { offsetInCU: 0x31B, offset: 0x9E918, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_equal_limb, symObjAddr: 0x74, symBinAddr: 0x2C3CE8, symSize: 0x5C }
-  - { offsetInCU: 0x517, offset: 0x9EB14, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_even, symObjAddr: 0xD0, symBinAddr: 0x2C3D44, symSize: 0x1C }
-  - { offsetInCU: 0x636, offset: 0x9EC33, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_less_than, symObjAddr: 0xEC, symBinAddr: 0x2C3D60, symSize: 0x54 }
-  - { offsetInCU: 0x6D9, offset: 0x9ECD6, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_less_than_limb, symObjAddr: 0x140, symBinAddr: 0x2C3DB4, symSize: 0x4C }
-  - { offsetInCU: 0x8A7, offset: 0x9EEA4, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_reduce_once, symObjAddr: 0x18C, symBinAddr: 0x2C3E00, symSize: 0xA8 }
-  - { offsetInCU: 0x90B, offset: 0x9EF08, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_reduce_once, symObjAddr: 0x18C, symBinAddr: 0x2C3E00, symSize: 0xA8 }
-  - { offsetInCU: 0xBAA, offset: 0x9F1A7, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_add_mod, symObjAddr: 0x234, symBinAddr: 0x2C3EA8, symSize: 0x110 }
-  - { offsetInCU: 0xC4C, offset: 0x9F249, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_add_mod, symObjAddr: 0x234, symBinAddr: 0x2C3EA8, symSize: 0x110 }
-  - { offsetInCU: 0xEDE, offset: 0x9F4DB, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_sub_mod, symObjAddr: 0x344, symBinAddr: 0x2C3FB8, symSize: 0xB0 }
-  - { offsetInCU: 0xF5E, offset: 0x9F55B, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_sub_mod, symObjAddr: 0x344, symBinAddr: 0x2C3FB8, symSize: 0xB0 }
-  - { offsetInCU: 0x10E1, offset: 0x9F6DE, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_shl_mod, symObjAddr: 0x3F4, symBinAddr: 0x2C4068, symSize: 0x178 }
-  - { offsetInCU: 0x13AB, offset: 0x9F9A8, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_select_512_32, symObjAddr: 0x56C, symBinAddr: 0x2C41E0, symSize: 0x1F4 }
-  - { offsetInCU: 0x1500, offset: 0x9FAFD, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_window5_split_window, symObjAddr: 0x760, symBinAddr: 0x2C43D4, symSize: 0x18 }
-  - { offsetInCU: 0x1567, offset: 0x9FB64, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_window5_unsplit_window, symObjAddr: 0x778, symBinAddr: 0x2C43EC, symSize: 0xC }
-  - { offsetInCU: 0x15A0, offset: 0x9FB9D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMB_shr, symObjAddr: 0x784, symBinAddr: 0x2C43F8, symSize: 0x8 }
-  - { offsetInCU: 0x1624, offset: 0x9FC21, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_limbs_mul_add_limb, symObjAddr: 0x78C, symBinAddr: 0x2C4400, symSize: 0x3C }
-  - { offsetInCU: 0x26, offset: 0x9FDD4, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_CRYPTO_memcmp, symObjAddr: 0x0, symBinAddr: 0x2C443C, symSize: 0x170 }
-  - { offsetInCU: 0x34, offset: 0x9FDE2, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_CRYPTO_memcmp, symObjAddr: 0x0, symBinAddr: 0x2C443C, symSize: 0x170 }
-  - { offsetInCU: 0x34, offset: 0x9FEE8, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_OPENSSL_armcap_P, symObjAddr: 0x374, symBinAddr: 0x10DAFE0, symSize: 0x0 }
-  - { offsetInCU: 0x26, offset: 0x9FF2A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul, symObjAddr: 0x0, symBinAddr: 0x2C45AC, symSize: 0x388 }
-  - { offsetInCU: 0x76, offset: 0x9FF7A, size: 0x8, addend: 0x0, symName: _ecp_nistz256_precomputed, symObjAddr: 0x1000, symBinAddr: 0x9AB000, symSize: 0x0 }
-  - { offsetInCU: 0xFA, offset: 0x9FFFE, size: 0x8, addend: 0x0, symName: _ONE, symObjAddr: 0x26000, symBinAddr: 0x9D0000, symSize: 0x0 }
-  - { offsetInCU: 0x35B, offset: 0xA025F, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul, symObjAddr: 0x0, symBinAddr: 0x2C45AC, symSize: 0x388 }
-  - { offsetInCU: 0xC66, offset: 0xA0B6A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul_base, symObjAddr: 0x388, symBinAddr: 0x2C4934, symSize: 0x204 }
-  - { offsetInCU: 0x1171, offset: 0xA1075, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul_base_vartime, symObjAddr: 0x58C, symBinAddr: 0x2C4B38, symSize: 0x1BC }
-  - { offsetInCU: 0x10, offset: 0xA144A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_set_encrypt_key, symObjAddr: 0x0, symBinAddr: 0x2C4D00, symSize: 0x1A0 }
-  - { offsetInCU: 0x50, offset: 0xA148A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_set_encrypt_key, symObjAddr: 0x0, symBinAddr: 0x2C4D00, symSize: 0x1A0 }
-  - { offsetInCU: 0x5E, offset: 0xA1498, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_encrypt, symObjAddr: 0x1A0, symBinAddr: 0x2C4EA0, symSize: 0x60 }
-  - { offsetInCU: 0x81, offset: 0xA14BB, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_ctr32_encrypt_blocks, symObjAddr: 0x200, symBinAddr: 0x2C4F00, symSize: 0x288 }
-  - { offsetInCU: 0x10, offset: 0xA14AC, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_init_clmul, symObjAddr: 0x0, symBinAddr: 0x2C5190, symSize: 0x130 }
-  - { offsetInCU: 0x48, offset: 0xA14E4, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_init_clmul, symObjAddr: 0x0, symBinAddr: 0x2C5190, symSize: 0x130 }
-  - { offsetInCU: 0x5F, offset: 0xA14FB, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_gmult_clmul, symObjAddr: 0x130, symBinAddr: 0x2C52C0, symSize: 0x70 }
-  - { offsetInCU: 0x75, offset: 0xA1511, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_ghash_clmul, symObjAddr: 0x1A0, symBinAddr: 0x2C5330, symSize: 0x160 }
-  - { offsetInCU: 0x7A, offset: 0xA1516, size: 0x8, addend: 0x0, symName: gcm_ghash_v8_4x, symObjAddr: 0x300, symBinAddr: 0x2C5490, symSize: 0x378 }
-  - { offsetInCU: 0x10, offset: 0xA1524, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ChaCha20_ctr32, symObjAddr: 0x0, symBinAddr: 0x2C5820, symSize: 0x3A0 }
-  - { offsetInCU: 0x48, offset: 0xA155C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ChaCha20_ctr32, symObjAddr: 0x0, symBinAddr: 0x2C5820, symSize: 0x3A0 }
-  - { offsetInCU: 0x4C, offset: 0xA1560, size: 0x8, addend: 0x0, symName: ChaCha20_neon, symObjAddr: 0x3A0, symBinAddr: 0x2C5BC0, symSize: 0x6C0 }
-  - { offsetInCU: 0x66, offset: 0xA157A, size: 0x8, addend: 0x0, symName: ChaCha20_512_neon, symObjAddr: 0xA60, symBinAddr: 0x2C6280, symSize: 0x1138 }
-  - { offsetInCU: 0x50, offset: 0xA15C6, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_chacha20_poly1305_seal, symObjAddr: 0x140, symBinAddr: 0x2C7500, symSize: 0x1180 }
-  - { offsetInCU: 0x66, offset: 0xA15DC, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_chacha20_poly1305_open, symObjAddr: 0x12C0, symBinAddr: 0x2C8680, symSize: 0x1410 }
-  - { offsetInCU: 0x10, offset: 0xA15D2, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_mul_mont, symObjAddr: 0x0, symBinAddr: 0x2C9AA0, symSize: 0x240 }
-  - { offsetInCU: 0x45, offset: 0xA1607, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_mul_mont, symObjAddr: 0x0, symBinAddr: 0x2C9AA0, symSize: 0x240 }
-  - { offsetInCU: 0x4D, offset: 0xA160F, size: 0x8, addend: 0x0, symName: __bn_sqr8x_mont, symObjAddr: 0x240, symBinAddr: 0x2C9CE0, symSize: 0x9E0 }
-  - { offsetInCU: 0x63, offset: 0xA1625, size: 0x8, addend: 0x0, symName: __bn_mul4x_mont, symObjAddr: 0xC20, symBinAddr: 0x2CA6C0, symSize: 0x650 }
-  - { offsetInCU: 0x10, offset: 0xA1634, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_mul_mont, symObjAddr: 0x0, symBinAddr: 0x2CAD20, symSize: 0x40 }
-  - { offsetInCU: 0x47, offset: 0xA166B, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_mul_mont, symObjAddr: 0x0, symBinAddr: 0x2CAD20, symSize: 0x40 }
-  - { offsetInCU: 0x5D, offset: 0xA1681, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_sqr_mont, symObjAddr: 0x40, symBinAddr: 0x2CAD60, symSize: 0x40 }
-  - { offsetInCU: 0x76, offset: 0xA169A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ecp_nistz256_neg, symObjAddr: 0x80, symBinAddr: 0x2CADA0, symSize: 0x40 }
-  - { offsetInCU: 0x81, offset: 0xA16A5, size: 0x8, addend: 0x0, symName: __ecp_nistz256_mul_mont, symObjAddr: 0xC0, symBinAddr: 0x2CADE0, symSize: 0x1E0 }
-  - { offsetInCU: 0x97, offset: 0xA16BB, size: 0x8, addend: 0x0, symName: __ecp_nistz256_sqr_mont, symObjAddr: 0x2A0, symBinAddr: 0x2CAFC0, symSize: 0x170 }
-  - { offsetInCU: 0xAB, offset: 0xA16CF, size: 0x8, addend: 0x0, symName: __ecp_nistz256_add_to, symObjAddr: 0x410, symBinAddr: 0x2CB130, symSize: 0x50 }
-  - { offsetInCU: 0xC3, offset: 0xA16E7, size: 0x8, addend: 0x0, symName: __ecp_nistz256_sub_from, symObjAddr: 0x460, symBinAddr: 0x2CB180, symSize: 0x50 }
-  - { offsetInCU: 0xD9, offset: 0xA16FD, size: 0x8, addend: 0x0, symName: __ecp_nistz256_sub_morf, symObjAddr: 0x4B0, symBinAddr: 0x2CB1D0, symSize: 0x50 }
-  - { offsetInCU: 0xEF, offset: 0xA1713, size: 0x8, addend: 0x0, symName: __ecp_nistz256_div_by_2, symObjAddr: 0x500, symBinAddr: 0x2CB220, symSize: 0x60 }
-  - { offsetInCU: 0x111, offset: 0xA1735, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_double, symObjAddr: 0x560, symBinAddr: 0x2CB280, symSize: 0x1E0 }
-  - { offsetInCU: 0x124, offset: 0xA1748, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_add, symObjAddr: 0x740, symBinAddr: 0x2CB460, symSize: 0x360 }
-  - { offsetInCU: 0x141, offset: 0xA1765, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_add_affine, symObjAddr: 0xAA0, symBinAddr: 0x2CB7C0, symSize: 0x2D0 }
-  - { offsetInCU: 0x156, offset: 0xA177A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_scalar_mul_mont, symObjAddr: 0xD70, symBinAddr: 0x2CBA90, symSize: 0x2B0 }
-  - { offsetInCU: 0x170, offset: 0xA1794, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_scalar_sqr_rep_mont, symObjAddr: 0x1020, symBinAddr: 0x2CBD40, symSize: 0x250 }
-  - { offsetInCU: 0x184, offset: 0xA17A8, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ecp_nistz256_select_w5, symObjAddr: 0x1270, symBinAddr: 0x2CBF90, symSize: 0x60 }
-  - { offsetInCU: 0x19A, offset: 0xA17BE, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ecp_nistz256_select_w7, symObjAddr: 0x12D0, symBinAddr: 0x2CBFF0, symSize: 0x44 }
-  - { offsetInCU: 0x10, offset: 0xA17B4, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_gcm_enc_kernel, symObjAddr: 0x0, symBinAddr: 0x2CC040, symSize: 0xB90 }
-  - { offsetInCU: 0x4C, offset: 0xA17F0, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_gcm_enc_kernel, symObjAddr: 0x0, symBinAddr: 0x2CC040, symSize: 0xB90 }
-  - { offsetInCU: 0x62, offset: 0xA1806, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_gcm_dec_kernel, symObjAddr: 0xB90, symBinAddr: 0x2CCBD0, symSize: 0xB98 }
-  - { offsetInCU: 0x10, offset: 0xA1800, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha512_block_data_order, symObjAddr: 0x0, symBinAddr: 0x2CD780, symSize: 0xE40 }
-  - { offsetInCU: 0x51, offset: 0xA1841, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha512_block_data_order, symObjAddr: 0x0, symBinAddr: 0x2CD780, symSize: 0xE40 }
-  - { offsetInCU: 0x51, offset: 0xA1841, size: 0x8, addend: 0x0, symName: sha512_block_armv8, symObjAddr: 0xE40, symBinAddr: 0x2CE5C0, symSize: 0x7E0 }
-  - { offsetInCU: 0x10, offset: 0xA184C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha256_block_data_order, symObjAddr: 0x0, symBinAddr: 0x2CEDC0, symSize: 0xE40 }
-  - { offsetInCU: 0x51, offset: 0xA188D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha256_block_data_order, symObjAddr: 0x0, symBinAddr: 0x2CEDC0, symSize: 0xE40 }
-  - { offsetInCU: 0x51, offset: 0xA188D, size: 0x8, addend: 0x0, symName: sha256_block_armv8, symObjAddr: 0xE40, symBinAddr: 0x2CFC00, symSize: 0x1F0 }
+  - { offsetInCU: 0x34, offset: 0x7789E, size: 0x8, addend: 0x0, symName: _CanvasNativeVersionString, symObjAddr: 0x0, symBinAddr: 0x965000, symSize: 0x0 }
+  - { offsetInCU: 0x69, offset: 0x778D3, size: 0x8, addend: 0x0, symName: _CanvasNativeVersionNumber, symObjAddr: 0x38, symBinAddr: 0x965038, symSize: 0x0 }
+  - { offsetInCU: 0x3F, offset: 0x77928, size: 0x8, addend: 0x0, symName: ___swift_memcpy16_8, symObjAddr: 0x28, symBinAddr: 0x8028, symSize: 0xC }
+  - { offsetInCU: 0x53, offset: 0x7793C, size: 0x8, addend: 0x0, symName: ___swift_noop_void_return, symObjAddr: 0x34, symBinAddr: 0x8034, symSize: 0x4 }
+  - { offsetInCU: 0x67, offset: 0x77950, size: 0x8, addend: 0x0, symName: '_$sSo6CGSizeVwet', symObjAddr: 0x38, symBinAddr: 0x8038, symSize: 0x20 }
+  - { offsetInCU: 0x7B, offset: 0x77964, size: 0x8, addend: 0x0, symName: '_$sSo6CGSizeVwst', symObjAddr: 0x58, symBinAddr: 0x8058, symSize: 0x28 }
+  - { offsetInCU: 0x8F, offset: 0x77978, size: 0x8, addend: 0x0, symName: '_$sSo6CGRectVwCP', symObjAddr: 0x94, symBinAddr: 0x8094, symSize: 0x30 }
+  - { offsetInCU: 0xA3, offset: 0x7798C, size: 0x8, addend: 0x0, symName: ___swift_memcpy32_8, symObjAddr: 0xC4, symBinAddr: 0x80C4, symSize: 0xC }
+  - { offsetInCU: 0xB7, offset: 0x779A0, size: 0x8, addend: 0x0, symName: '_$sSo6CGRectVwet', symObjAddr: 0xD0, symBinAddr: 0x80D0, symSize: 0x20 }
+  - { offsetInCU: 0xCB, offset: 0x779B4, size: 0x8, addend: 0x0, symName: '_$sSo6CGRectVwst', symObjAddr: 0xF0, symBinAddr: 0x80F0, symSize: 0x2C }
+  - { offsetInCU: 0x4F, offset: 0x77B9D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC11_WriteQueue33_05178D28796EA758448493B56DC45144LLSo011NSOperationE0CSgvpZ', symObjAddr: 0x2AE8, symBinAddr: 0x115E520, symSize: 0x0 }
+  - { offsetInCU: 0x69, offset: 0x77BB7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10_ReadQueue33_05178D28796EA758448493B56DC45144LLSo011NSOperationE0CSgvpZ', symObjAddr: 0x2AF0, symBinAddr: 0x115E528, symSize: 0x0 }
+  - { offsetInCU: 0x9D, offset: 0x77BEB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC19getBytesFromUIImageySo13NSMutableDataCSo0G0CFZTo', symObjAddr: 0x4, symBinAddr: 0x8194, symSize: 0x38 }
+  - { offsetInCU: 0xF3, offset: 0x77C41, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13createPatternys5Int64VAF_So7UIImageCSStFZTo', symObjAddr: 0x40, symBinAddr: 0x81D0, symSize: 0x70 }
+  - { offsetInCU: 0x144, offset: 0x77C92, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC25loadImageAssetWithContextySbs5Int64V_So7UIImageCtFZTo', symObjAddr: 0xB4, symBinAddr: 0x8244, symSize: 0x44 }
+  - { offsetInCU: 0x19F, offset: 0x77CED, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dyys5Int64V_So7UIImageCS2ftFZTo', symObjAddr: 0xFC, symBinAddr: 0x828C, symSize: 0x50 }
+  - { offsetInCU: 0x204, offset: 0x77D52, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dy2dw2dhys5Int64V_So7UIImageCS4ftFZTo', symObjAddr: 0x150, symBinAddr: 0x82E0, symSize: 0x68 }
+  - { offsetInCU: 0x27D, offset: 0x77DCB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2sx2sy2sw2sh2dx2dy2dw2dhys5Int64V_So7UIImageCS8ftFZTo', symObjAddr: 0x1BC, symBinAddr: 0x834C, symSize: 0x98 }
+  - { offsetInCU: 0x2DA, offset: 0x77E28, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23initWebGPUWithViewLayerys5Int64VAF_AFs6UInt32VAHtFZTo', symObjAddr: 0x258, symBinAddr: 0x83E8, symSize: 0x14 }
+  - { offsetInCU: 0x35C, offset: 0x77EAA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC18initWebGPUWithViewys5Int64VAF_AFs6UInt32VAHtFZTo', symObjAddr: 0x270, symBinAddr: 0x8400, symSize: 0x14 }
+  - { offsetInCU: 0x40B, offset: 0x77F59, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14initGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbtFZTo', symObjAddr: 0x2C8, symBinAddr: 0x8458, symSize: 0x50 }
+  - { offsetInCU: 0x4DC, offset: 0x7802A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC20initSharedGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbAFtFZTo', symObjAddr: 0x364, symBinAddr: 0x84F4, symSize: 0x58 }
+  - { offsetInCU: 0x5B6, offset: 0x78104, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC24initGLWithWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbtFZTo', symObjAddr: 0x404, symBinAddr: 0x8594, symSize: 0x58 }
+  - { offsetInCU: 0x695, offset: 0x781E3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC26initSharedGLWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbAFtFZTo', symObjAddr: 0x4AC, symBinAddr: 0x863C, symSize: 0x60 }
+  - { offsetInCU: 0x741, offset: 0x7828F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15resize2DContextyys5Int64V_S2ftFZTo', symObjAddr: 0x510, symBinAddr: 0x86A0, symSize: 0x8 }
+  - { offsetInCU: 0x7AA, offset: 0x782F8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14flush2DContextyys5Int64VFZTo', symObjAddr: 0x51C, symBinAddr: 0x86AC, symSize: 0x8 }
+  - { offsetInCU: 0x801, offset: 0x7834F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC7flushGLySbs5Int64VFZTo', symObjAddr: 0x538, symBinAddr: 0x86C8, symSize: 0x8 }
+  - { offsetInCU: 0x858, offset: 0x783A6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9releaseGLyys5Int64VFZTo', symObjAddr: 0x544, symBinAddr: 0x86D4, symSize: 0x8 }
+  - { offsetInCU: 0x8AF, offset: 0x783FD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC12getGLPointerys5Int64VAFFZTo', symObjAddr: 0x550, symBinAddr: 0x86E0, symSize: 0x8 }
+  - { offsetInCU: 0x906, offset: 0x78454, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC16releaseGLPointeryys5Int64VFZTo', symObjAddr: 0x55C, symBinAddr: 0x86EC, symSize: 0x8 }
+  - { offsetInCU: 0x985, offset: 0x784D3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15create2DContextys5Int64VAF_s5Int32VAHSbSfA2HSfAHtFZTo', symObjAddr: 0x56C, symBinAddr: 0x86FC, symSize: 0x24 }
+  - { offsetInCU: 0xA36, offset: 0x78584, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23updateGLSurfaceWithViewyys5Int64V_s5Int32VAhFtFZTo', symObjAddr: 0x594, symBinAddr: 0x8724, symSize: 0x14 }
+  - { offsetInCU: 0xAA9, offset: 0x785F7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC6test2Dyys5Int64VFZTo', symObjAddr: 0x5AC, symBinAddr: 0x873C, symSize: 0x8 }
+  - { offsetInCU: 0xB00, offset: 0x7864E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13testToDataURLySSs5Int64VFZTo', symObjAddr: 0x60C, symBinAddr: 0x879C, symSize: 0x74 }
+  - { offsetInCU: 0xB8B, offset: 0x786D9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZTo', symObjAddr: 0x814, symBinAddr: 0x89A4, symSize: 0xA0 }
+  - { offsetInCU: 0xBDC, offset: 0x7872A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZTo', symObjAddr: 0xB1C, symBinAddr: 0x8CAC, symSize: 0x98 }
+  - { offsetInCU: 0xC2D, offset: 0x7877B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZTo', symObjAddr: 0xE70, symBinAddr: 0x9000, symSize: 0x98 }
+  - { offsetInCU: 0xC89, offset: 0x787D7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZTo', symObjAddr: 0x1298, symBinAddr: 0x9428, symSize: 0xD8 }
+  - { offsetInCU: 0xCD1, offset: 0x7881F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC32getPixelsPerInchForCurrentDeviceSSyFZTo', symObjAddr: 0x1374, symBinAddr: 0x9504, symSize: 0x34 }
+  - { offsetInCU: 0xD31, offset: 0x7887F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCACycfcTo', symObjAddr: 0x13F8, symBinAddr: 0x9588, symSize: 0x3C }
+  - { offsetInCU: 0xD82, offset: 0x788D0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC19getBytesFromUIImageySo13NSMutableDataCSo0G0CFZTf4nd_n', symObjAddr: 0x1468, symBinAddr: 0x95F8, symSize: 0x2AC }
+  - { offsetInCU: 0xFB6, offset: 0x78B04, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13createPatternys5Int64VAF_So7UIImageCSStFZTf4nnnd_n', symObjAddr: 0x1714, symBinAddr: 0x98A4, symSize: 0x264 }
+  - { offsetInCU: 0x11B0, offset: 0x78CFE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC25loadImageAssetWithContextySbs5Int64V_So7UIImageCtFZTf4nnd_n', symObjAddr: 0x1978, symBinAddr: 0x9B08, symSize: 0xEC }
+  - { offsetInCU: 0x12AD, offset: 0x78DFB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dyys5Int64V_So7UIImageCS2ftFZTf4nnnnd_n', symObjAddr: 0x1A64, symBinAddr: 0x9BF4, symSize: 0x1B4 }
+  - { offsetInCU: 0x1422, offset: 0x78F70, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dy2dw2dhys5Int64V_So7UIImageCS4ftFZTf4nnnnnnd_n', symObjAddr: 0x1C18, symBinAddr: 0x9DA8, symSize: 0x1CC }
+  - { offsetInCU: 0x15B7, offset: 0x79105, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2sx2sy2sw2sh2dx2dy2dw2dhys5Int64V_So7UIImageCS8ftFZTf4nnnnnnnnnnd_n', symObjAddr: 0x1DE4, symBinAddr: 0x9F74, symSize: 0x1E0 }
+  - { offsetInCU: 0x17A3, offset: 0x792F1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZTf4nnnd_n', symObjAddr: 0x1FC4, symBinAddr: 0xA154, symSize: 0x1B4 }
+  - { offsetInCU: 0x186D, offset: 0x793BB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZTf4nnnnd_n', symObjAddr: 0x231C, symBinAddr: 0xA4AC, symSize: 0x1D4 }
+  - { offsetInCU: 0x194E, offset: 0x7949C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC32getPixelsPerInchForCurrentDeviceSSyFZTf4d_n', symObjAddr: 0x24F0, symBinAddr: 0xA680, symSize: 0x114 }
+  - { offsetInCU: 0x19F9, offset: 0x79547, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgACIeyByy_SSSgADIeggg_TR', symObjAddr: 0x8B4, symBinAddr: 0x8A44, symSize: 0x78 }
+  - { offsetInCU: 0x1A11, offset: 0x7955F, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgSo6NSDataCSgIeyByy_SSSgAFIeggg_TR', symObjAddr: 0xBB4, symBinAddr: 0x8D44, symSize: 0x54 }
+  - { offsetInCU: 0x1A7E, offset: 0x795CC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCfETo', symObjAddr: 0x1464, symBinAddr: 0x95F4, symSize: 0x4 }
+  - { offsetInCU: 0x1B09, offset: 0x79657, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCMa', symObjAddr: 0x2604, symBinAddr: 0xA794, symSize: 0x20 }
+  - { offsetInCU: 0x1B1D, offset: 0x7966B, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgACIeyByy_SSSgADIeggg_TRTA', symObjAddr: 0x2648, symBinAddr: 0xA7D8, symSize: 0x8 }
+  - { offsetInCU: 0x1B3C, offset: 0x7968A, size: 0x8, addend: 0x0, symName: '_$sSo7NSErrorCSg10ObjectiveC8ObjCBoolVIeyByy_ACSbIeggy_TRTA', symObjAddr: 0x2650, symBinAddr: 0xA7E0, symSize: 0x18 }
+  - { offsetInCU: 0x1B65, offset: 0x796B3, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgSo6NSDataCSgIeyByy_SSSgAFIeggg_TRTA', symObjAddr: 0x2668, symBinAddr: 0xA7F8, symSize: 0x8 }
+  - { offsetInCU: 0x1B79, offset: 0x796C7, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCMa', symObjAddr: 0x2670, symBinAddr: 0xA800, symSize: 0x3C }
+  - { offsetInCU: 0x1B8D, offset: 0x796DB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZyyYbcfU_TA', symObjAddr: 0x26F0, symBinAddr: 0xA880, symSize: 0x34 }
+  - { offsetInCU: 0x1BA1, offset: 0x796EF, size: 0x8, addend: 0x0, symName: _block_copy_helper, symObjAddr: 0x2724, symBinAddr: 0xA8B4, symSize: 0x10 }
+  - { offsetInCU: 0x1BB5, offset: 0x79703, size: 0x8, addend: 0x0, symName: _block_destroy_helper, symObjAddr: 0x2734, symBinAddr: 0xA8C4, symSize: 0x8 }
+  - { offsetInCU: 0x1BC9, offset: 0x79717, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZyyYbcfU_yyYbcfU0_TA', symObjAddr: 0x2760, symBinAddr: 0xA8F0, symSize: 0x40 }
+  - { offsetInCU: 0x1BFD, offset: 0x7974B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZyyYbcfU_yyYbcfU0_TA', symObjAddr: 0x27E4, symBinAddr: 0xA974, symSize: 0x40 }
+  - { offsetInCU: 0x1C3B, offset: 0x79789, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZyyYbcfU_yyYbcfU_TA', symObjAddr: 0x2824, symBinAddr: 0xA9B4, symSize: 0x28 }
+  - { offsetInCU: 0x1C6F, offset: 0x797BD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZyyYbcfU_yyYbcfU_TA', symObjAddr: 0x28A4, symBinAddr: 0xAA34, symSize: 0x3C }
+  - { offsetInCU: 0x1CA3, offset: 0x797F1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZyyYbcfU_yyYbcfU0_TA', symObjAddr: 0x290C, symBinAddr: 0xAA9C, symSize: 0x30 }
+  - { offsetInCU: 0x1CDF, offset: 0x7982D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZyyYbcfU_TA', symObjAddr: 0x2978, symBinAddr: 0xAB08, symSize: 0x10 }
+  - { offsetInCU: 0x1CF3, offset: 0x79841, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZyyYbcfU_yyYbcfU_TA', symObjAddr: 0x2988, symBinAddr: 0xAB18, symSize: 0x40 }
+  - { offsetInCU: 0x21C0, offset: 0x79D0E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC19getBytesFromUIImageySo13NSMutableDataCSo0G0CFZ', symObjAddr: 0x0, symBinAddr: 0x8190, symSize: 0x4 }
+  - { offsetInCU: 0x21DB, offset: 0x79D29, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x3C, symBinAddr: 0x81CC, symSize: 0x4 }
+  - { offsetInCU: 0x21F6, offset: 0x79D44, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC25loadImageAssetWithContextySbs5Int64V_So7UIImageCtFZ', symObjAddr: 0xB0, symBinAddr: 0x8240, symSize: 0x4 }
+  - { offsetInCU: 0x2217, offset: 0x79D65, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dyys5Int64V_So7UIImageCS2ftFZ', symObjAddr: 0xF8, symBinAddr: 0x8288, symSize: 0x4 }
+  - { offsetInCU: 0x2232, offset: 0x79D80, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dy2dw2dhys5Int64V_So7UIImageCS4ftFZ', symObjAddr: 0x14C, symBinAddr: 0x82DC, symSize: 0x4 }
+  - { offsetInCU: 0x224D, offset: 0x79D9B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2sx2sy2sw2sh2dx2dy2dw2dhys5Int64V_So7UIImageCS8ftFZ', symObjAddr: 0x1B8, symBinAddr: 0x8348, symSize: 0x4 }
+  - { offsetInCU: 0x2268, offset: 0x79DB6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23initWebGPUWithViewLayerys5Int64VAF_AFs6UInt32VAHtFZ', symObjAddr: 0x254, symBinAddr: 0x83E4, symSize: 0x4 }
+  - { offsetInCU: 0x22F6, offset: 0x79E44, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC18initWebGPUWithViewys5Int64VAF_AFs6UInt32VAHtFZ', symObjAddr: 0x26C, symBinAddr: 0x83FC, symSize: 0x4 }
+  - { offsetInCU: 0x2375, offset: 0x79EC3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14initGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbtFZ', symObjAddr: 0x284, symBinAddr: 0x8414, symSize: 0x44 }
+  - { offsetInCU: 0x24B3, offset: 0x7A001, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC20initSharedGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbAFtFZ', symObjAddr: 0x318, symBinAddr: 0x84A8, symSize: 0x4C }
+  - { offsetInCU: 0x25FC, offset: 0x7A14A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC24initGLWithWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbtFZ', symObjAddr: 0x3BC, symBinAddr: 0x854C, symSize: 0x48 }
+  - { offsetInCU: 0x2744, offset: 0x7A292, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC26initSharedGLWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbAFtFZ', symObjAddr: 0x45C, symBinAddr: 0x85EC, symSize: 0x50 }
+  - { offsetInCU: 0x28A1, offset: 0x7A3EF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15resize2DContextyys5Int64V_S2ftFZ', symObjAddr: 0x50C, symBinAddr: 0x869C, symSize: 0x4 }
+  - { offsetInCU: 0x2913, offset: 0x7A461, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14flush2DContextyys5Int64VFZ', symObjAddr: 0x518, symBinAddr: 0x86A8, symSize: 0x4 }
+  - { offsetInCU: 0x2956, offset: 0x7A4A4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC7flushGLySbs5Int64VFZ', symObjAddr: 0x524, symBinAddr: 0x86B4, symSize: 0x14 }
+  - { offsetInCU: 0x299B, offset: 0x7A4E9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9releaseGLyys5Int64VFZ', symObjAddr: 0x540, symBinAddr: 0x86D0, symSize: 0x4 }
+  - { offsetInCU: 0x29DE, offset: 0x7A52C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC12getGLPointerys5Int64VAFFZ', symObjAddr: 0x54C, symBinAddr: 0x86DC, symSize: 0x4 }
+  - { offsetInCU: 0x2A21, offset: 0x7A56F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC16releaseGLPointeryys5Int64VFZ', symObjAddr: 0x558, symBinAddr: 0x86E8, symSize: 0x4 }
+  - { offsetInCU: 0x2A64, offset: 0x7A5B2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15create2DContextys5Int64VAF_s5Int32VAHSbSfA2HSfAHtFZ', symObjAddr: 0x564, symBinAddr: 0x86F4, symSize: 0x8 }
+  - { offsetInCU: 0x2B4B, offset: 0x7A699, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23updateGLSurfaceWithViewyys5Int64V_s5Int32VAhFtFZ', symObjAddr: 0x590, symBinAddr: 0x8720, symSize: 0x4 }
+  - { offsetInCU: 0x2BCA, offset: 0x7A718, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC6test2Dyys5Int64VFZ', symObjAddr: 0x5A8, symBinAddr: 0x8738, symSize: 0x4 }
+  - { offsetInCU: 0x2C0D, offset: 0x7A75B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13testToDataURLySSs5Int64VFZ', symObjAddr: 0x5B4, symBinAddr: 0x8744, symSize: 0x58 }
+  - { offsetInCU: 0x2CCE, offset: 0x7A81C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZ', symObjAddr: 0x680, symBinAddr: 0x8810, symSize: 0x4 }
+  - { offsetInCU: 0x2CE2, offset: 0x7A830, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZyyYbcfU_', symObjAddr: 0x684, symBinAddr: 0x8814, symSize: 0x190 }
+  - { offsetInCU: 0x2D82, offset: 0x7A8D0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZ', symObjAddr: 0x92C, symBinAddr: 0x8ABC, symSize: 0x2C }
+  - { offsetInCU: 0x2D96, offset: 0x7A8E4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZyyYbcfU_', symObjAddr: 0x958, symBinAddr: 0x8AE8, symSize: 0x1C4 }
+  - { offsetInCU: 0x2E80, offset: 0x7A9CE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZ', symObjAddr: 0xC08, symBinAddr: 0x8D98, symSize: 0x2C }
+  - { offsetInCU: 0x2E94, offset: 0x7A9E2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZyyYbcfU_', symObjAddr: 0xC34, symBinAddr: 0x8DC4, symSize: 0x23C }
+  - { offsetInCU: 0x2F48, offset: 0x7AA96, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZ', symObjAddr: 0xF08, symBinAddr: 0x9098, symSize: 0x4 }
+  - { offsetInCU: 0x2F5C, offset: 0x7AAAA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZyyYbcfU_', symObjAddr: 0xF0C, symBinAddr: 0x909C, symSize: 0x38C }
+  - { offsetInCU: 0x31F3, offset: 0x7AD41, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC32getPixelsPerInchForCurrentDeviceSSyFZ', symObjAddr: 0x1370, symBinAddr: 0x9500, symSize: 0x4 }
+  - { offsetInCU: 0x320E, offset: 0x7AD5C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCACycfC', symObjAddr: 0x13A8, symBinAddr: 0x9538, symSize: 0x20 }
+  - { offsetInCU: 0x3222, offset: 0x7AD70, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCACycfc', symObjAddr: 0x13C8, symBinAddr: 0x9558, symSize: 0x30 }
+  - { offsetInCU: 0x3258, offset: 0x7ADA6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCfD', symObjAddr: 0x1434, symBinAddr: 0x95C4, symSize: 0x30 }
+  - { offsetInCU: 0x4F, offset: 0x7AFDE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19shared_context_view33_508084857CA7D194CA72FEB80DD78002LLSo7GLKViewCvpZ', symObjAddr: 0x55E0, symBinAddr: 0x115E560, symSize: 0x0 }
+  - { offsetInCU: 0x69, offset: 0x7AFF8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15_shared_context33_508084857CA7D194CA72FEB80DD78002LLs5Int64VvpZ', symObjAddr: 0x55E8, symBinAddr: 0x115E568, symSize: 0x0 }
+  - { offsetInCU: 0x83, offset: 0x7B012, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5storeSo19NSMutableDictionaryCvpZ', symObjAddr: 0x55F0, symBinAddr: 0x115E570, symSize: 0x0 }
+  - { offsetInCU: 0x9D, offset: 0x7B02C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5views33_508084857CA7D194CA72FEB80DD78002LLSo10NSMapTableCySo8NSStringCACGvpZ', symObjAddr: 0x55F8, symBinAddr: 0x115E578, symSize: 0x0 }
+  - { offsetInCU: 0xAB, offset: 0x7B03A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19shared_context_view33_508084857CA7D194CA72FEB80DD78002LL_WZ', symObjAddr: 0x0, symBinAddr: 0xAC40, symSize: 0x40 }
+  - { offsetInCU: 0xF0, offset: 0x7B07F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5store_WZ', symObjAddr: 0x40, symBinAddr: 0xAC80, symSize: 0x30 }
+  - { offsetInCU: 0x135, offset: 0x7B0C4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5views33_508084857CA7D194CA72FEB80DD78002LL_WZ', symObjAddr: 0xA8, symBinAddr: 0xACE8, symSize: 0x40 }
+  - { offsetInCU: 0x187, offset: 0x7B116, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC3ptrSvSgvgTo', symObjAddr: 0x194, symBinAddr: 0xADD4, symSize: 0x10 }
+  - { offsetInCU: 0x1A7, offset: 0x7B136, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC3ptrSvSgvgTo', symObjAddr: 0x194, symBinAddr: 0xADD4, symSize: 0x10 }
+  - { offsetInCU: 0x1DD, offset: 0x7B16C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC3ptrSvSgvsTo', symObjAddr: 0x1A4, symBinAddr: 0xADE4, symSize: 0x10 }
+  - { offsetInCU: 0x1FD, offset: 0x7B18C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC3ptrSvSgvsTo', symObjAddr: 0x1A4, symBinAddr: 0xADE4, symSize: 0x10 }
+  - { offsetInCU: 0x236, offset: 0x7B1C5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6mtlPtrSvSgvgTo', symObjAddr: 0x1B4, symBinAddr: 0xADF4, symSize: 0x10 }
+  - { offsetInCU: 0x256, offset: 0x7B1E5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6mtlPtrSvSgvgTo', symObjAddr: 0x1B4, symBinAddr: 0xADF4, symSize: 0x10 }
+  - { offsetInCU: 0x28C, offset: 0x7B21B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6mtlPtrSvSgvsTo', symObjAddr: 0x1C4, symBinAddr: 0xAE04, symSize: 0x10 }
+  - { offsetInCU: 0x2AC, offset: 0x7B23B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6mtlPtrSvSgvsTo', symObjAddr: 0x1C4, symBinAddr: 0xAE04, symSize: 0x10 }
+  - { offsetInCU: 0x2E5, offset: 0x7B274, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvgTo', symObjAddr: 0x29C, symBinAddr: 0xAEDC, symSize: 0x44 }
+  - { offsetInCU: 0x322, offset: 0x7B2B1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvsTo', symObjAddr: 0x324, symBinAddr: 0xAF64, symSize: 0x30 }
+  - { offsetInCU: 0x3B1, offset: 0x7B340, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8nativeGLs5Int64VvgTo', symObjAddr: 0x578, symBinAddr: 0xB1B8, symSize: 0x44 }
+  - { offsetInCU: 0x409, offset: 0x7B398, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8nativeGLs5Int64VvsTo', symObjAddr: 0x600, symBinAddr: 0xB240, symSize: 0x48 }
+  - { offsetInCU: 0x464, offset: 0x7B3F3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13nativeContexts5Int64VvgTo', symObjAddr: 0x648, symBinAddr: 0xB288, symSize: 0x44 }
+  - { offsetInCU: 0x4BC, offset: 0x7B44B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13nativeContexts5Int64VvsTo', symObjAddr: 0x6D0, symBinAddr: 0xB310, symSize: 0x48 }
+  - { offsetInCU: 0x517, offset: 0x7B4A6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15native2DContexts5Int64VvgTo', symObjAddr: 0x718, symBinAddr: 0xB358, symSize: 0x10 }
+  - { offsetInCU: 0x537, offset: 0x7B4C6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15native2DContexts5Int64VvgTo', symObjAddr: 0x718, symBinAddr: 0xB358, symSize: 0x10 }
+  - { offsetInCU: 0x56D, offset: 0x7B4FC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15native2DContexts5Int64VvsTo', symObjAddr: 0x728, symBinAddr: 0xB368, symSize: 0x10 }
+  - { offsetInCU: 0x58D, offset: 0x7B51C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15native2DContexts5Int64VvsTo', symObjAddr: 0x728, symBinAddr: 0xB368, symSize: 0x10 }
+  - { offsetInCU: 0x5C6, offset: 0x7B555, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7mtlViewSo7MTKViewCvgTo', symObjAddr: 0x738, symBinAddr: 0xB378, symSize: 0x10 }
+  - { offsetInCU: 0x5E6, offset: 0x7B575, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7mtlViewSo7MTKViewCvgTo', symObjAddr: 0x738, symBinAddr: 0xB378, symSize: 0x10 }
+  - { offsetInCU: 0x61E, offset: 0x7B5AD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7mtlViewSo7MTKViewCvsTo', symObjAddr: 0x748, symBinAddr: 0xB388, symSize: 0x34 }
+  - { offsetInCU: 0x677, offset: 0x7B606, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7glkViewAA0A7GLKViewCvgTo', symObjAddr: 0x77C, symBinAddr: 0xB3BC, symSize: 0x10 }
+  - { offsetInCU: 0x697, offset: 0x7B626, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7glkViewAA0A7GLKViewCvgTo', symObjAddr: 0x77C, symBinAddr: 0xB3BC, symSize: 0x10 }
+  - { offsetInCU: 0x6CF, offset: 0x7B65E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7glkViewAA0A7GLKViewCvsTo', symObjAddr: 0x78C, symBinAddr: 0xB3CC, symSize: 0x34 }
+  - { offsetInCU: 0x728, offset: 0x7B6B7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC4is2DSbvgTo', symObjAddr: 0x7C0, symBinAddr: 0xB400, symSize: 0x10 }
+  - { offsetInCU: 0x748, offset: 0x7B6D7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC4is2DSbvgTo', symObjAddr: 0x7C0, symBinAddr: 0xB400, symSize: 0x10 }
+  - { offsetInCU: 0x77E, offset: 0x7B70D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC4is2DSbvsTo', symObjAddr: 0x7D0, symBinAddr: 0xB410, symSize: 0x10 }
+  - { offsetInCU: 0x79E, offset: 0x7B72D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC4is2DSbvsTo', symObjAddr: 0x7D0, symBinAddr: 0xB410, symSize: 0x10 }
+  - { offsetInCU: 0x7D7, offset: 0x7B766, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7isMetalSbvgTo', symObjAddr: 0x7E0, symBinAddr: 0xB420, symSize: 0x10 }
+  - { offsetInCU: 0x7F7, offset: 0x7B786, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7isMetalSbvgTo', symObjAddr: 0x7E0, symBinAddr: 0xB420, symSize: 0x10 }
+  - { offsetInCU: 0x82D, offset: 0x7B7BC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7isMetalSbvsTo', symObjAddr: 0x7F0, symBinAddr: 0xB430, symSize: 0x10 }
+  - { offsetInCU: 0x84D, offset: 0x7B7DC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7isMetalSbvsTo', symObjAddr: 0x7F0, symBinAddr: 0xB430, symSize: 0x10 }
+  - { offsetInCU: 0x870, offset: 0x7B7FF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18drawingBufferWidthSivgTo', symObjAddr: 0x800, symBinAddr: 0xB440, symSize: 0x34 }
+  - { offsetInCU: 0x8A2, offset: 0x7B831, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19drawingBufferHeightSivgTo', symObjAddr: 0x904, symBinAddr: 0xB544, symSize: 0x34 }
+  - { offsetInCU: 0x8EA, offset: 0x7B879, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5widthSfvgTo', symObjAddr: 0xA08, symBinAddr: 0xB648, symSize: 0x20 }
+  - { offsetInCU: 0x952, offset: 0x7B8E1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6heightSfvgTo', symObjAddr: 0xA4C, symBinAddr: 0xB68C, symSize: 0x20 }
+  - { offsetInCU: 0x9F1, offset: 0x7B980, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11initContextyySS_S4bs5Int32VS5btFTo', symObjAddr: 0xAB4, symBinAddr: 0xB6F4, symSize: 0xC4 }
+  - { offsetInCU: 0xAB4, offset: 0x7BA43, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17initWebGPUContextyys5Int64VFTo', symObjAddr: 0xD10, symBinAddr: 0xB950, symSize: 0x30 }
+  - { offsetInCU: 0xB64, offset: 0x7BAF3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC015initContextWithE10AttributesyySS_S4bs5Int32VS5btFTo', symObjAddr: 0x15C8, symBinAddr: 0xC208, symSize: 0xC4 }
+  - { offsetInCU: 0xBCE, offset: 0x7BB5D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15create2DContextys5Int64VSb_S3bs5Int32VS5bAHtFTo', symObjAddr: 0x18E4, symBinAddr: 0xC524, symSize: 0xB0 }
+  - { offsetInCU: 0xC0B, offset: 0x7BB9A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11forceLayoutyy12CoreGraphics7CGFloatV_AGtFTo', symObjAddr: 0x1A54, symBinAddr: 0xC694, symSize: 0xB8 }
+  - { offsetInCU: 0xC83, offset: 0x7BC12, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8snapshotySo7UIImageCSgSbFTo', symObjAddr: 0x1BF0, symBinAddr: 0xC830, symSize: 0x3C }
+  - { offsetInCU: 0xCB6, offset: 0x7BC45, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8rendererAA9NSCRenderCSgvgTo', symObjAddr: 0x1C2C, symBinAddr: 0xC86C, symSize: 0x10 }
+  - { offsetInCU: 0xCD6, offset: 0x7BC65, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8rendererAA9NSCRenderCSgvgTo', symObjAddr: 0x1C2C, symBinAddr: 0xC86C, symSize: 0x10 }
+  - { offsetInCU: 0xD10, offset: 0x7BC9F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8rendererAA9NSCRenderCSgvsTo', symObjAddr: 0x1C3C, symBinAddr: 0xC87C, symSize: 0x34 }
+  - { offsetInCU: 0xD6B, offset: 0x7BCFA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6renderSbyFTo', symObjAddr: 0x1CB8, symBinAddr: 0xC8F8, symSize: 0x48 }
+  - { offsetInCU: 0xE05, offset: 0x7BD94, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13context2DTestyys5Int64VFTo', symObjAddr: 0x1D4C, symBinAddr: 0xC98C, symSize: 0x64 }
+  - { offsetInCU: 0xECA, offset: 0x7BE59, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC22context2DTestToDataURLySSs5Int64VFTo', symObjAddr: 0x1E08, symBinAddr: 0xCA48, symSize: 0x94 }
+  - { offsetInCU: 0xF57, offset: 0x7BEE6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC23enterBackgroundListeneryycSgvsTo', symObjAddr: 0x1EDC, symBinAddr: 0xCB1C, symSize: 0x6C }
+  - { offsetInCU: 0xFB9, offset: 0x7BF48, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC20becomeActiveListeneryycSgvsTo', symObjAddr: 0x1FEC, symBinAddr: 0xCC2C, symSize: 0x6C }
+  - { offsetInCU: 0x1016, offset: 0x7BFA5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvgTo', symObjAddr: 0x2058, symBinAddr: 0xCC98, symSize: 0xB0 }
+  - { offsetInCU: 0x1068, offset: 0x7BFF7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvsTo', symObjAddr: 0x21D8, symBinAddr: 0xCE18, symSize: 0x94 }
+  - { offsetInCU: 0x10FA, offset: 0x7C089, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5coderACSgSo7NSCoderC_tcfcTo', symObjAddr: 0x2EC4, symBinAddr: 0xDB04, symSize: 0x28 }
+  - { offsetInCU: 0x114F, offset: 0x7C0DE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5frameACSo6CGRectV_tcfcTo', symObjAddr: 0x3944, symBinAddr: 0xE584, symSize: 0x20 }
+  - { offsetInCU: 0x1182, offset: 0x7C111, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvgTo', symObjAddr: 0x3964, symBinAddr: 0xE5A4, symSize: 0x10 }
+  - { offsetInCU: 0x11A2, offset: 0x7C131, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvgTo', symObjAddr: 0x3964, symBinAddr: 0xE5A4, symSize: 0x10 }
+  - { offsetInCU: 0x11DA, offset: 0x7C169, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvsTo', symObjAddr: 0x3974, symBinAddr: 0xE5B4, symSize: 0x34 }
+  - { offsetInCU: 0x1248, offset: 0x7C1D7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13readyListenerAA0cE0_pSgvgTo', symObjAddr: 0x3A28, symBinAddr: 0xE668, symSize: 0x20 }
+  - { offsetInCU: 0x12A2, offset: 0x7C231, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13readyListenerAA0cE0_pSgvsTo', symObjAddr: 0x3A48, symBinAddr: 0xE688, symSize: 0x34 }
+  - { offsetInCU: 0x1302, offset: 0x7C291, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11setListeneryyAA0cE0_pSgFTo', symObjAddr: 0x3AAC, symBinAddr: 0xE6EC, symSize: 0x34 }
+  - { offsetInCU: 0x1446, offset: 0x7C3D5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC14layoutSubviewsyyFTo', symObjAddr: 0x3DF8, symBinAddr: 0xEA38, symSize: 0x28 }
+  - { offsetInCU: 0x1479, offset: 0x7C408, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCfDTo', symObjAddr: 0x4124, symBinAddr: 0xED64, symSize: 0x24 }
+  - { offsetInCU: 0x14B4, offset: 0x7C443, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC21getBoundingClientRectyySo6UIViewC_SvtFZTo', symObjAddr: 0x4210, symBinAddr: 0xEE50, symSize: 0x34 }
+  - { offsetInCU: 0x14E7, offset: 0x7C476, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC14shared_context33_508084857CA7D194CA72FEB80DD78002LLs5Int64VvgZTf4d_n', symObjAddr: 0x4BAC, symBinAddr: 0xF7EC, symSize: 0x2A8 }
+  - { offsetInCU: 0x1664, offset: 0x7C5F3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC21getBoundingClientRectyySo6UIViewC_SvtFZTf4nnd_n', symObjAddr: 0x4F18, symBinAddr: 0xFB58, symSize: 0xA0 }
+  - { offsetInCU: 0x18E0, offset: 0x7C86F, size: 0x8, addend: 0x0, symName: '_$sIeg_IeyB_TR', symObjAddr: 0x1EB0, symBinAddr: 0xCAF0, symSize: 0x2C }
+  - { offsetInCU: 0x18F8, offset: 0x7C887, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_So8NSStringCABIeyByy_TR', symObjAddr: 0x2160, symBinAddr: 0xCDA0, symSize: 0x78 }
+  - { offsetInCU: 0x1910, offset: 0x7C89F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvpACTK', symObjAddr: 0x22C8, symBinAddr: 0xCF08, symSize: 0x94 }
+  - { offsetInCU: 0x1948, offset: 0x7C8D7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvpACTk', symObjAddr: 0x235C, symBinAddr: 0xCF9C, symSize: 0xB8 }
+  - { offsetInCU: 0x198A, offset: 0x7C919, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCytIegnnr_SSABIeggg_TR', symObjAddr: 0x2414, symBinAddr: 0xD054, symSize: 0x6C }
+  - { offsetInCU: 0x1A3A, offset: 0x7C9C9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCfETo', symObjAddr: 0x4148, symBinAddr: 0xED88, symSize: 0xC4 }
+  - { offsetInCU: 0x1A6A, offset: 0x7C9F9, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_SgWOy', symObjAddr: 0x4244, symBinAddr: 0xEE84, symSize: 0x10 }
+  - { offsetInCU: 0x1A7E, offset: 0x7CA0D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCMa', symObjAddr: 0x4254, symBinAddr: 0xEE94, symSize: 0x20 }
+  - { offsetInCU: 0x1A92, offset: 0x7CA21, size: 0x8, addend: 0x0, symName: '_$ss29getContiguousArrayStorageType3fors01_bcD0CyxGmxm_tlFSo18NSLayoutConstraintC_Tgm5', symObjAddr: 0x4274, symBinAddr: 0xEEB4, symSize: 0x64 }
+  - { offsetInCU: 0x1C99, offset: 0x7CC28, size: 0x8, addend: 0x0, symName: ___swift_instantiateConcreteTypeFromMangledName, symObjAddr: 0x4E54, symBinAddr: 0xFA94, symSize: 0x40 }
+  - { offsetInCU: 0x1CAD, offset: 0x7CC3C, size: 0x8, addend: 0x0, symName: '_$sypSgWOh', symObjAddr: 0x4E94, symBinAddr: 0xFAD4, symSize: 0x40 }
+  - { offsetInCU: 0x1CC1, offset: 0x7CC50, size: 0x8, addend: 0x0, symName: ___swift_project_boxed_opaque_existential_0, symObjAddr: 0x4ED4, symBinAddr: 0xFB14, symSize: 0x24 }
+  - { offsetInCU: 0x1CD5, offset: 0x7CC64, size: 0x8, addend: 0x0, symName: ___swift_destroy_boxed_opaque_existential_0, symObjAddr: 0x4EF8, symBinAddr: 0xFB38, symSize: 0x20 }
+  - { offsetInCU: 0x1CF4, offset: 0x7CC83, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSo19UIGestureRecognizerCIeyByy_SSADIeggg_TRTA', symObjAddr: 0x53E4, symBinAddr: 0x10024, symSize: 0x48 }
+  - { offsetInCU: 0x1D1D, offset: 0x7CCAC, size: 0x8, addend: 0x0, symName: _block_copy_helper, symObjAddr: 0x542C, symBinAddr: 0x1006C, symSize: 0x10 }
+  - { offsetInCU: 0x1D31, offset: 0x7CCC0, size: 0x8, addend: 0x0, symName: _block_destroy_helper, symObjAddr: 0x543C, symBinAddr: 0x1007C, symSize: 0x8 }
+  - { offsetInCU: 0x1D45, offset: 0x7CCD4, size: 0x8, addend: 0x0, symName: '_$sIeg_SgWOe', symObjAddr: 0x5444, symBinAddr: 0x10084, symSize: 0x10 }
+  - { offsetInCU: 0x1D64, offset: 0x7CCF3, size: 0x8, addend: 0x0, symName: '_$sIeyB_Ieg_TRTA', symObjAddr: 0x5454, symBinAddr: 0x10094, symSize: 0xC }
+  - { offsetInCU: 0x1D8D, offset: 0x7CD1C, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCytIegnnr_SSABIeggg_TRTA', symObjAddr: 0x5484, symBinAddr: 0x100C4, symSize: 0x8 }
+  - { offsetInCU: 0x1DAC, offset: 0x7CD3B, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_SSABytIegnnr_TRTA', symObjAddr: 0x548C, symBinAddr: 0x100CC, symSize: 0x30 }
+  - { offsetInCU: 0x1DD5, offset: 0x7CD64, size: 0x8, addend: 0x0, symName: '_$sypWOb', symObjAddr: 0x54BC, symBinAddr: 0x100FC, symSize: 0x10 }
+  - { offsetInCU: 0x1DE9, offset: 0x7CD78, size: 0x8, addend: 0x0, symName: '_$sypWOc', symObjAddr: 0x5504, symBinAddr: 0x10144, symSize: 0x3C }
+  - { offsetInCU: 0x206E, offset: 0x7CFFD, size: 0x8, addend: 0x0, symName: '_$sSD17dictionaryLiteralSDyxq_Gx_q_td_tcfCSS_ypTgm5Tf4g_n', symObjAddr: 0x4A94, symBinAddr: 0xF6D4, symSize: 0x118 }
+  - { offsetInCU: 0x2514, offset: 0x7D4A3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvg', symObjAddr: 0x2E0, symBinAddr: 0xAF20, symSize: 0x44 }
+  - { offsetInCU: 0x2547, offset: 0x7D4D6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvs', symObjAddr: 0x354, symBinAddr: 0xAF94, symSize: 0xEC }
+  - { offsetInCU: 0x2593, offset: 0x7D522, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvM', symObjAddr: 0x440, symBinAddr: 0xB080, symSize: 0x58 }
+  - { offsetInCU: 0x25B8, offset: 0x7D547, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvM.resume.0', symObjAddr: 0x498, symBinAddr: 0xB0D8, symSize: 0xE0 }
+  - { offsetInCU: 0x25F9, offset: 0x7D588, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8nativeGLs5Int64Vvg', symObjAddr: 0x5BC, symBinAddr: 0xB1FC, symSize: 0x44 }
+  - { offsetInCU: 0x2651, offset: 0x7D5E0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13nativeContexts5Int64Vvg', symObjAddr: 0x68C, symBinAddr: 0xB2CC, symSize: 0x44 }
+  - { offsetInCU: 0x27BF, offset: 0x7D74E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18drawingBufferWidthSivg', symObjAddr: 0x834, symBinAddr: 0xB474, symSize: 0xD0 }
+  - { offsetInCU: 0x28E4, offset: 0x7D873, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19drawingBufferHeightSivg', symObjAddr: 0x938, symBinAddr: 0xB578, symSize: 0xD0 }
+  - { offsetInCU: 0x2A2A, offset: 0x7D9B9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5widthSfvg', symObjAddr: 0xA28, symBinAddr: 0xB668, symSize: 0x24 }
+  - { offsetInCU: 0x2A72, offset: 0x7DA01, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6heightSfvg', symObjAddr: 0xA6C, symBinAddr: 0xB6AC, symSize: 0x24 }
+  - { offsetInCU: 0x2AA6, offset: 0x7DA35, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11initContextyySS_S4bs5Int32VS5btF', symObjAddr: 0xA90, symBinAddr: 0xB6D0, symSize: 0x24 }
+  - { offsetInCU: 0x2C34, offset: 0x7DBC3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17initWebGPUContextyys5Int64VF', symObjAddr: 0xB78, symBinAddr: 0xB7B8, symSize: 0x198 }
+  - { offsetInCU: 0x3027, offset: 0x7DFB6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC015initContextWithE10AttributesyySS_S4bs5Int32VS5btF', symObjAddr: 0xD40, symBinAddr: 0xB980, symSize: 0x888 }
+  - { offsetInCU: 0x382A, offset: 0x7E7B9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15create2DContextys5Int64VSb_S3bs5Int32VS5bAHtF', symObjAddr: 0x168C, symBinAddr: 0xC2CC, symSize: 0x258 }
+  - { offsetInCU: 0x3C5C, offset: 0x7EBEB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11forceLayoutyy12CoreGraphics7CGFloatV_AGtF', symObjAddr: 0x1994, symBinAddr: 0xC5D4, symSize: 0xC0 }
+  - { offsetInCU: 0x3CED, offset: 0x7EC7C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8snapshotySo7UIImageCSgSbF', symObjAddr: 0x1B0C, symBinAddr: 0xC74C, symSize: 0xE4 }
+  - { offsetInCU: 0x3E48, offset: 0x7EDD7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6renderSbyF', symObjAddr: 0x1C70, symBinAddr: 0xC8B0, symSize: 0x48 }
+  - { offsetInCU: 0x3ECE, offset: 0x7EE5D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13context2DTestyys5Int64VF', symObjAddr: 0x1D00, symBinAddr: 0xC940, symSize: 0x4C }
+  - { offsetInCU: 0x3FEF, offset: 0x7EF7E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC22context2DTestToDataURLySSs5Int64VF', symObjAddr: 0x1DB0, symBinAddr: 0xC9F0, symSize: 0x58 }
+  - { offsetInCU: 0x40E5, offset: 0x7F074, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvg', symObjAddr: 0x2108, symBinAddr: 0xCD48, symSize: 0x58 }
+  - { offsetInCU: 0x4131, offset: 0x7F0C0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvs', symObjAddr: 0x226C, symBinAddr: 0xCEAC, symSize: 0x5C }
+  - { offsetInCU: 0x415A, offset: 0x7F0E9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvM', symObjAddr: 0x2480, symBinAddr: 0xD0C0, symSize: 0x44 }
+  - { offsetInCU: 0x4180, offset: 0x7F10F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvM.resume.0', symObjAddr: 0x24C4, symBinAddr: 0xD104, symSize: 0x4 }
+  - { offsetInCU: 0x4242, offset: 0x7F1D1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5coderACSgSo7NSCoderC_tcfc', symObjAddr: 0x24C8, symBinAddr: 0xD108, symSize: 0x9FC }
+  - { offsetInCU: 0x4465, offset: 0x7F3F4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5frameACSo6CGRectV_tcfC', symObjAddr: 0x2EEC, symBinAddr: 0xDB2C, symSize: 0x50 }
+  - { offsetInCU: 0x448E, offset: 0x7F41D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5frameACSo6CGRectV_tcfc', symObjAddr: 0x2F3C, symBinAddr: 0xDB7C, symSize: 0xA08 }
+  - { offsetInCU: 0x46D2, offset: 0x7F661, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvW', symObjAddr: 0x39A8, symBinAddr: 0xE5E8, symSize: 0x80 }
+  - { offsetInCU: 0x47C8, offset: 0x7F757, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11setListeneryyAA0cE0_pSgF', symObjAddr: 0x3A7C, symBinAddr: 0xE6BC, symSize: 0x30 }
+  - { offsetInCU: 0x4866, offset: 0x7F7F5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6resize33_508084857CA7D194CA72FEB80DD78002LLyyF', symObjAddr: 0x3AE0, symBinAddr: 0xE720, symSize: 0x144 }
+  - { offsetInCU: 0x4A67, offset: 0x7F9F6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC14layoutSubviewsyyF', symObjAddr: 0x3C24, symBinAddr: 0xE864, symSize: 0x1D4 }
+  - { offsetInCU: 0x4CE4, offset: 0x7FC73, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCfD', symObjAddr: 0x3E20, symBinAddr: 0xEA60, symSize: 0x304 }
+  - { offsetInCU: 0x4D74, offset: 0x7FD03, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC21getBoundingClientRectyySo6UIViewC_SvtFZ', symObjAddr: 0x420C, symBinAddr: 0xEE4C, symSize: 0x4 }
+  - { offsetInCU: 0x4D9C, offset: 0x7FD2B, size: 0x8, addend: 0x0, symName: '_$ss22__RawDictionaryStorageC4findys10_HashTableV6BucketV6bucket_Sb5foundtxSHRzlFSS_Tg5', symObjAddr: 0x42D8, symBinAddr: 0xEF18, symSize: 0x64 }
+  - { offsetInCU: 0x4DF6, offset: 0x7FD85, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV7_insert2at3key5valueys10_HashTableV6BucketV_xnq_ntFSS_ypTg5', symObjAddr: 0x433C, symBinAddr: 0xEF7C, symSize: 0x6C }
+  - { offsetInCU: 0x4E76, offset: 0x7FE05, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV12mutatingFind_8isUniques10_HashTableV6BucketV6bucket_Sb5foundtx_SbtFSS_ypTg5', symObjAddr: 0x43A8, symBinAddr: 0xEFE8, symSize: 0xD8 }
+  - { offsetInCU: 0x4EB3, offset: 0x7FE42, size: 0x8, addend: 0x0, symName: '_$ss22__RawDictionaryStorageC4find_9hashValues10_HashTableV6BucketV6bucket_Sb5foundtx_SitSHRzlFSS_Tg5', symObjAddr: 0x4480, symBinAddr: 0xF0C0, symSize: 0xE0 }
+  - { offsetInCU: 0x4F2E, offset: 0x7FEBD, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV4copyyyFSS_ypTg5', symObjAddr: 0x4560, symBinAddr: 0xF1A0, symSize: 0x1F4 }
+  - { offsetInCU: 0x4FEA, offset: 0x7FF79, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV20_copyOrMoveAndResize8capacity12moveElementsySi_SbtFSS_ypTg5', symObjAddr: 0x4754, symBinAddr: 0xF394, symSize: 0x340 }
+  - { offsetInCU: 0x27, offset: 0x801E1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative7GLUtilsCfD', symObjAddr: 0x0, symBinAddr: 0x101E4, symSize: 0x10 }
+  - { offsetInCU: 0x62, offset: 0x8021C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative7GLUtilsCMa', symObjAddr: 0x10, symBinAddr: 0x101F4, symSize: 0x20 }
+  - { offsetInCU: 0x1AF, offset: 0x80369, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative7GLUtilsCfD', symObjAddr: 0x0, symBinAddr: 0x101E4, symSize: 0x10 }
+  - { offsetInCU: 0x65, offset: 0x803F8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8mPrograms6UInt32VvgTo', symObjAddr: 0x0, symBinAddr: 0x10214, symSize: 0x10 }
+  - { offsetInCU: 0x85, offset: 0x80418, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8mPrograms6UInt32VvgTo', symObjAddr: 0x0, symBinAddr: 0x10214, symSize: 0x10 }
+  - { offsetInCU: 0xBB, offset: 0x8044E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8mPrograms6UInt32VvsTo', symObjAddr: 0x10, symBinAddr: 0x10224, symSize: 0x10 }
+  - { offsetInCU: 0xDB, offset: 0x8046E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8mPrograms6UInt32VvsTo', symObjAddr: 0x10, symBinAddr: 0x10224, symSize: 0x10 }
+  - { offsetInCU: 0x114, offset: 0x804A7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3rbos6UInt32VvgTo', symObjAddr: 0x20, symBinAddr: 0x10234, symSize: 0x44 }
+  - { offsetInCU: 0x16C, offset: 0x804FF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3rbos6UInt32VvsTo', symObjAddr: 0x64, symBinAddr: 0x10278, symSize: 0x48 }
+  - { offsetInCU: 0x1C7, offset: 0x8055A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3fbos6UInt32VvgTo', symObjAddr: 0xAC, symBinAddr: 0x102C0, symSize: 0x44 }
+  - { offsetInCU: 0x21F, offset: 0x805B2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3fbos6UInt32VvsTo', symObjAddr: 0xF0, symBinAddr: 0x10304, symSize: 0x48 }
+  - { offsetInCU: 0x27A, offset: 0x8060D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC5widthSivgTo', symObjAddr: 0x138, symBinAddr: 0x1034C, symSize: 0x10 }
+  - { offsetInCU: 0x29A, offset: 0x8062D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC5widthSivgTo', symObjAddr: 0x138, symBinAddr: 0x1034C, symSize: 0x10 }
+  - { offsetInCU: 0x2D0, offset: 0x80663, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC5widthSivsTo', symObjAddr: 0x148, symBinAddr: 0x1035C, symSize: 0x10 }
+  - { offsetInCU: 0x2F0, offset: 0x80683, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC5widthSivsTo', symObjAddr: 0x148, symBinAddr: 0x1035C, symSize: 0x10 }
+  - { offsetInCU: 0x329, offset: 0x806BC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC6heightSivgTo', symObjAddr: 0x158, symBinAddr: 0x1036C, symSize: 0x10 }
+  - { offsetInCU: 0x349, offset: 0x806DC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC6heightSivgTo', symObjAddr: 0x158, symBinAddr: 0x1036C, symSize: 0x10 }
+  - { offsetInCU: 0x37F, offset: 0x80712, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC6heightSivsTo', symObjAddr: 0x168, symBinAddr: 0x1037C, symSize: 0x10 }
+  - { offsetInCU: 0x39F, offset: 0x80732, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC6heightSivsTo', symObjAddr: 0x168, symBinAddr: 0x1037C, symSize: 0x10 }
+  - { offsetInCU: 0x3D8, offset: 0x8076B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC2abs6UInt32VvgTo', symObjAddr: 0x178, symBinAddr: 0x1038C, symSize: 0x44 }
+  - { offsetInCU: 0x430, offset: 0x807C3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC2abs6UInt32VvsTo', symObjAddr: 0x1BC, symBinAddr: 0x103D0, symSize: 0x48 }
+  - { offsetInCU: 0x48B, offset: 0x8081E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3poss5Int32VvgTo', symObjAddr: 0x204, symBinAddr: 0x10418, symSize: 0x10 }
+  - { offsetInCU: 0x4AB, offset: 0x8083E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3poss5Int32VvgTo', symObjAddr: 0x204, symBinAddr: 0x10418, symSize: 0x10 }
+  - { offsetInCU: 0x4E1, offset: 0x80874, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3poss5Int32VvsTo', symObjAddr: 0x214, symBinAddr: 0x10428, symSize: 0x10 }
+  - { offsetInCU: 0x501, offset: 0x80894, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3poss5Int32VvsTo', symObjAddr: 0x214, symBinAddr: 0x10428, symSize: 0x10 }
+  - { offsetInCU: 0x53A, offset: 0x808CD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10samplerPoss5Int32VvgTo', symObjAddr: 0x224, symBinAddr: 0x10438, symSize: 0x10 }
+  - { offsetInCU: 0x55A, offset: 0x808ED, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10samplerPoss5Int32VvgTo', symObjAddr: 0x224, symBinAddr: 0x10438, symSize: 0x10 }
+  - { offsetInCU: 0x590, offset: 0x80923, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10samplerPoss5Int32VvsTo', symObjAddr: 0x234, symBinAddr: 0x10448, symSize: 0x10 }
+  - { offsetInCU: 0x5B0, offset: 0x80943, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10samplerPoss5Int32VvsTo', symObjAddr: 0x234, symBinAddr: 0x10448, symSize: 0x10 }
+  - { offsetInCU: 0x5E9, offset: 0x8097C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9vextexBufSaySfGvgTo', symObjAddr: 0x244, symBinAddr: 0x10458, symSize: 0x48 }
+  - { offsetInCU: 0x63F, offset: 0x809D2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9vextexBufSaySfGvsTo', symObjAddr: 0x28C, symBinAddr: 0x104A0, symSize: 0x40 }
+  - { offsetInCU: 0x682, offset: 0x80A15, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13SIZE_OF_FLOATSivgZTo', symObjAddr: 0x2CC, symBinAddr: 0x104E0, symSize: 0x8 }
+  - { offsetInCU: 0x69E, offset: 0x80A31, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13VERTEX_SHADERSSvgZTo', symObjAddr: 0x2D4, symBinAddr: 0x104E8, symSize: 0x2C }
+  - { offsetInCU: 0x6D0, offset: 0x80A63, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7surfaceSo9IOSurfaceCSgvgTo', symObjAddr: 0x300, symBinAddr: 0x10514, symSize: 0x10 }
+  - { offsetInCU: 0x6F0, offset: 0x80A83, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7surfaceSo9IOSurfaceCSgvgTo', symObjAddr: 0x300, symBinAddr: 0x10514, symSize: 0x10 }
+  - { offsetInCU: 0x728, offset: 0x80ABB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7surfaceSo9IOSurfaceCSgvsTo', symObjAddr: 0x310, symBinAddr: 0x10524, symSize: 0x34 }
+  - { offsetInCU: 0x781, offset: 0x80B14, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8pixelBufs9UnmanagedVySo11CVBufferRefaGSgvgTo', symObjAddr: 0x418, symBinAddr: 0x1062C, symSize: 0x10 }
+  - { offsetInCU: 0x7A1, offset: 0x80B34, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8pixelBufs9UnmanagedVySo11CVBufferRefaGSgvgTo', symObjAddr: 0x418, symBinAddr: 0x1062C, symSize: 0x10 }
+  - { offsetInCU: 0x7D7, offset: 0x80B6A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8pixelBufs9UnmanagedVySo11CVBufferRefaGSgvsTo', symObjAddr: 0x428, symBinAddr: 0x1063C, symSize: 0x10 }
+  - { offsetInCU: 0x7F7, offset: 0x80B8A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8pixelBufs9UnmanagedVySo11CVBufferRefaGSgvsTo', symObjAddr: 0x428, symBinAddr: 0x1063C, symSize: 0x10 }
+  - { offsetInCU: 0x846, offset: 0x80BD9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCACycfcTo', symObjAddr: 0x5BC, symBinAddr: 0x10790, symSize: 0x20 }
+  - { offsetInCU: 0x878, offset: 0x80C0B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7destroyyyFTo', symObjAddr: 0x720, symBinAddr: 0x108F4, symSize: 0x28 }
+  - { offsetInCU: 0x8D0, offset: 0x80C63, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10texImage2Dyys5Int32V_A4fA9NSCCanvasCAHSbtFTo', symObjAddr: 0x75C, symBinAddr: 0x10930, symSize: 0x88 }
+  - { offsetInCU: 0x934, offset: 0x80CC7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9drawFrame6buffer5width6height14internalFormat6format10flipYWebGLySo11CVBufferRefa_S2is5Int32VANSbtFTo', symObjAddr: 0x7E4, symBinAddr: 0x109B8, symSize: 0x7C }
+  - { offsetInCU: 0x9D6, offset: 0x80D69, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13createSurfaceyyFTo', symObjAddr: 0xC0C, symBinAddr: 0x10DE0, symSize: 0x28 }
+  - { offsetInCU: 0xAC0, offset: 0x80E53, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCMa', symObjAddr: 0x59C, symBinAddr: 0x10770, symSize: 0x20 }
+  - { offsetInCU: 0xB34, offset: 0x80EC7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCfETo', symObjAddr: 0xC64, symBinAddr: 0x10E38, symSize: 0x58 }
+  - { offsetInCU: 0x123B, offset: 0x815CE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCACycfC', symObjAddr: 0x438, symBinAddr: 0x1064C, symSize: 0x20 }
+  - { offsetInCU: 0x1255, offset: 0x815E8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCACycfc', symObjAddr: 0x458, symBinAddr: 0x1066C, symSize: 0x104 }
+  - { offsetInCU: 0x1287, offset: 0x8161A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7destroyyyF', symObjAddr: 0x5DC, symBinAddr: 0x107B0, symSize: 0x144 }
+  - { offsetInCU: 0x1442, offset: 0x817D5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10texImage2Dyys5Int32V_A4fA9NSCCanvasCAHSbtF', symObjAddr: 0x748, symBinAddr: 0x1091C, symSize: 0x14 }
+  - { offsetInCU: 0x14F3, offset: 0x81886, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13createSurfaceyyF', symObjAddr: 0x860, symBinAddr: 0x10A34, symSize: 0x3AC }
+  - { offsetInCU: 0x1863, offset: 0x81BF6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCfD', symObjAddr: 0xC34, symBinAddr: 0x10E08, symSize: 0x30 }
+  - { offsetInCU: 0x194E, offset: 0x81CE1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10texImage2Dyys5Int32V_A4fA9NSCCanvasCAHSbtFTf4ddnndnndn_n', symObjAddr: 0xCBC, symBinAddr: 0x10E90, symSize: 0x65C }
+  - { offsetInCU: 0x214C, offset: 0x824DF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9drawFrame6buffer5width6height14internalFormat6format10flipYWebGLySo11CVBufferRefa_S2is5Int32VANSbtFTf4nnnnndn_n', symObjAddr: 0x135C, symBinAddr: 0x11530, symSize: 0x6C8 }
+  - { offsetInCU: 0x10C, offset: 0x82E9F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC6target6actionAEypSg_10ObjectiveC8SelectorVSgtcfcTo', symObjAddr: 0xED4, symBinAddr: 0x12AA4, symSize: 0x68 }
+  - { offsetInCU: 0x19C, offset: 0x82F2F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerCfETo', symObjAddr: 0xF48, symBinAddr: 0x12B18, symSize: 0x10 }
+  - { offsetInCU: 0x1CB, offset: 0x82F5E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC6handleyySo19UIGestureRecognizerCFTo', symObjAddr: 0xF58, symBinAddr: 0x12B28, symSize: 0x4 }
+  - { offsetInCU: 0x368, offset: 0x830FB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerCACycfcTo', symObjAddr: 0x16DC, symBinAddr: 0x132AC, symSize: 0x2C }
+  - { offsetInCU: 0x5D4, offset: 0x83367, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerCfETo', symObjAddr: 0x1744, symBinAddr: 0x13314, symSize: 0x68 }
+  - { offsetInCU: 0x603, offset: 0x83396, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerCMa', symObjAddr: 0x17AC, symBinAddr: 0x1337C, symSize: 0x20 }
+  - { offsetInCU: 0x617, offset: 0x833AA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerCMa', symObjAddr: 0x17CC, symBinAddr: 0x1339C, symSize: 0x20 }
+  - { offsetInCU: 0x62B, offset: 0x833BE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwCP', symObjAddr: 0x17EC, symBinAddr: 0x133BC, symSize: 0x30 }
+  - { offsetInCU: 0x63F, offset: 0x833D2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwxx', symObjAddr: 0x181C, symBinAddr: 0x133EC, symSize: 0x8 }
+  - { offsetInCU: 0x653, offset: 0x833E6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwcp', symObjAddr: 0x1824, symBinAddr: 0x133F4, symSize: 0x3C }
+  - { offsetInCU: 0x667, offset: 0x833FA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwca', symObjAddr: 0x1860, symBinAddr: 0x13430, symSize: 0x50 }
+  - { offsetInCU: 0x67B, offset: 0x8340E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwta', symObjAddr: 0x18BC, symBinAddr: 0x13480, symSize: 0x40 }
+  - { offsetInCU: 0x68F, offset: 0x83422, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwet', symObjAddr: 0x18FC, symBinAddr: 0x134C0, symSize: 0x48 }
+  - { offsetInCU: 0x6A3, offset: 0x83436, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwst', symObjAddr: 0x1944, symBinAddr: 0x13508, symSize: 0x40 }
+  - { offsetInCU: 0x6B7, offset: 0x8344A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVMa', symObjAddr: 0x1984, symBinAddr: 0x13548, symSize: 0x10 }
+  - { offsetInCU: 0x6CB, offset: 0x8345E, size: 0x8, addend: 0x0, symName: '_$sypSgWOc', symObjAddr: 0x1994, symBinAddr: 0x13558, symSize: 0x48 }
+  - { offsetInCU: 0x6DF, offset: 0x83472, size: 0x8, addend: 0x0, symName: '_$sSo7UITouchCSo8NSObjectCSH10ObjectiveCWl', symObjAddr: 0x1AA0, symBinAddr: 0x135A0, symSize: 0x58 }
+  - { offsetInCU: 0x6F3, offset: 0x83486, size: 0x8, addend: 0x0, symName: '_$sSh8IteratorV8_VariantOyx__GSHRzlWOe', symObjAddr: 0x1AF8, symBinAddr: 0x135F8, symSize: 0x8 }
+  - { offsetInCU: 0x761, offset: 0x834F4, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_SgWOe', symObjAddr: 0x1DEC, symBinAddr: 0x138EC, symSize: 0x10 }
+  - { offsetInCU: 0xCBB, offset: 0x83A4E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC12touchesBegan_4withyShySo7UITouchCG_So7UIEventCtF', symObjAddr: 0x0, symBinAddr: 0x11BF8, symSize: 0x540 }
+  - { offsetInCU: 0xF57, offset: 0x83CEA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC12touchesMoved_4withyShySo7UITouchCG_So7UIEventCtF', symObjAddr: 0x54C, symBinAddr: 0x12144, symSize: 0xE0 }
+  - { offsetInCU: 0xFD6, offset: 0x83D69, size: 0x8, addend: 0x0, symName: '_$sSa6remove2atxSi_tF12CanvasNative15NSCTouchHandlerC7PointerV_Tg5', symObjAddr: 0x6F0, symBinAddr: 0x122D4, symSize: 0x9C }
+  - { offsetInCU: 0x1069, offset: 0x83DFC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC6target6actionAEypSg_10ObjectiveC8SelectorVSgtcfc', symObjAddr: 0xDCC, symBinAddr: 0x1299C, symSize: 0x108 }
+  - { offsetInCU: 0x11B3, offset: 0x83F46, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC6onMove33_044DDF836BDB3B89B481C6F58BB6EF6BLLyySo19UIGestureRecognizerC_ShySo7UITouchCGSgtF', symObjAddr: 0x12D0, symBinAddr: 0x12EA0, symSize: 0x40C }
+  - { offsetInCU: 0x18C9, offset: 0x8465C, size: 0x8, addend: 0x0, symName: '_$ss12_ArrayBufferV20_consumeAndCreateNewAByxGyF12CanvasNative15NSCTouchHandlerC7PointerV_Tg5', symObjAddr: 0x1B00, symBinAddr: 0x13600, symSize: 0x14 }
+  - { offsetInCU: 0x1968, offset: 0x846FB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC6canvasAcA9NSCCanvasC_tcfcTf4gn_n', symObjAddr: 0x1B14, symBinAddr: 0x13614, symSize: 0x1E4 }
+  - { offsetInCU: 0x27, offset: 0x848D8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC14FAILED_TO_LOADSSvgZTo', symObjAddr: 0x0, symBinAddr: 0x138FC, symSize: 0x2C }
+  - { offsetInCU: 0x4B, offset: 0x848FC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queueSo012OS_dispatch_E0CvpZ', symObjAddr: 0x2D8, symBinAddr: 0x115E888, symSize: 0x0 }
+  - { offsetInCU: 0x65, offset: 0x84916, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC14FAILED_TO_LOADSSvgZTo', symObjAddr: 0x0, symBinAddr: 0x138FC, symSize: 0x2C }
+  - { offsetInCU: 0x98, offset: 0x84949, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queueSo012OS_dispatch_E0CvgZTo', symObjAddr: 0x178, symBinAddr: 0x13A74, symSize: 0x40 }
+  - { offsetInCU: 0x104, offset: 0x849B5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCACycfcTo', symObjAddr: 0x228, symBinAddr: 0x13B24, symSize: 0x3C }
+  - { offsetInCU: 0x156, offset: 0x84A07, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queue_WZ', symObjAddr: 0x2C, symBinAddr: 0x13928, symSize: 0x10C }
+  - { offsetInCU: 0x181, offset: 0x84A32, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCMa', symObjAddr: 0x208, symBinAddr: 0x13B04, symSize: 0x20 }
+  - { offsetInCU: 0x195, offset: 0x84A46, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCfETo', symObjAddr: 0x294, symBinAddr: 0x13B90, symSize: 0x4 }
+  - { offsetInCU: 0x1C0, offset: 0x84A71, size: 0x8, addend: 0x0, symName: '_$sSo17OS_dispatch_queueCMa', symObjAddr: 0x298, symBinAddr: 0x13B94, symSize: 0x3C }
+  - { offsetInCU: 0x348, offset: 0x84BF9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queueSo012OS_dispatch_E0CvgZ', symObjAddr: 0x138, symBinAddr: 0x13A34, symSize: 0x40 }
+  - { offsetInCU: 0x388, offset: 0x84C39, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCACycfC', symObjAddr: 0x1B8, symBinAddr: 0x13AB4, symSize: 0x20 }
+  - { offsetInCU: 0x39C, offset: 0x84C4D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCACycfc', symObjAddr: 0x1D8, symBinAddr: 0x13AD4, symSize: 0x30 }
+  - { offsetInCU: 0x3D8, offset: 0x84C89, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCfD', symObjAddr: 0x264, symBinAddr: 0x13B60, symSize: 0x30 }
+  - { offsetInCU: 0x2B, offset: 0x84CD7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC18createTextureCacheSo017CVOpenGLESTextureF3RefaSgyFZ', symObjAddr: 0x0, symBinAddr: 0x13BD0, symSize: 0xA4 }
+  - { offsetInCU: 0x66, offset: 0x84D12, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC18createTextureCacheSo017CVOpenGLESTextureF3RefaSgyFZTo', symObjAddr: 0xA4, symBinAddr: 0x13C74, symSize: 0xA4 }
+  - { offsetInCU: 0xF9, offset: 0x84DA5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11createImageySo11CVBufferRefaSgSo022CVOpenGLESTextureCacheG0a_AFSo012CFDictionaryG0aSgs6UInt32Vs5Int32VA2p2NSitFZTo', symObjAddr: 0x1D8, symBinAddr: 0x13DA8, symSize: 0x110 }
+  - { offsetInCU: 0x1A2, offset: 0x84E4E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11setupRenderAA9NSCRenderCyFZTo', symObjAddr: 0x30C, symBinAddr: 0x13EDC, symSize: 0x28 }
+  - { offsetInCU: 0x222, offset: 0x84ECE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC9drawFrameyySo8AVPlayerC_So0F15ItemVideoOutputCSo6CGSizeVAA9NSCRenderCs5Int32VANSbtFZTo', symObjAddr: 0x338, symBinAddr: 0x13F08, symSize: 0xA0 }
+  - { offsetInCU: 0x29B, offset: 0x84F47, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11writeToFileyySo6NSDataC_SStKFZTo', symObjAddr: 0x4D0, symBinAddr: 0x140A0, symSize: 0x15C }
+  - { offsetInCU: 0x330, offset: 0x84FDC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCACycfcTo', symObjAddr: 0x67C, symBinAddr: 0x1424C, symSize: 0x3C }
+  - { offsetInCU: 0x381, offset: 0x8502D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC9drawFrameyySo8AVPlayerC_So0F15ItemVideoOutputCSo6CGSizeVAA9NSCRenderCs5Int32VANSbtFZTf4nnnnnndd_n', symObjAddr: 0x6E8, symBinAddr: 0x142B8, symSize: 0x160 }
+  - { offsetInCU: 0x4DF, offset: 0x8518B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC7getFile33_F00B23A4165DD6ABFCD23C8811C7DF43LLyS2SKFZTf4nd_g', symObjAddr: 0x848, symBinAddr: 0x14418, symSize: 0x2E4 }
+  - { offsetInCU: 0x5AE, offset: 0x8525A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCMa', symObjAddr: 0xB2C, symBinAddr: 0x146FC, symSize: 0x20 }
+  - { offsetInCU: 0x5C2, offset: 0x8526E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOAEs5ErrorAAWl', symObjAddr: 0xB4C, symBinAddr: 0x1471C, symSize: 0x44 }
+  - { offsetInCU: 0x5D6, offset: 0x85282, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwCP', symObjAddr: 0xB90, symBinAddr: 0x14760, symSize: 0x2C }
+  - { offsetInCU: 0x5EA, offset: 0x85296, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwxx', symObjAddr: 0xBBC, symBinAddr: 0x1478C, symSize: 0x8 }
+  - { offsetInCU: 0x5FE, offset: 0x852AA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwca', symObjAddr: 0xBC4, symBinAddr: 0x14794, symSize: 0x40 }
+  - { offsetInCU: 0x612, offset: 0x852BE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwta', symObjAddr: 0xC10, symBinAddr: 0x147D4, symSize: 0x30 }
+  - { offsetInCU: 0x626, offset: 0x852D2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwet', symObjAddr: 0xC40, symBinAddr: 0x14804, symSize: 0x48 }
+  - { offsetInCU: 0x63A, offset: 0x852E6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwst', symObjAddr: 0xC88, symBinAddr: 0x1484C, symSize: 0x3C }
+  - { offsetInCU: 0x64E, offset: 0x852FA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwug', symObjAddr: 0xCC4, symBinAddr: 0x14888, symSize: 0x8 }
+  - { offsetInCU: 0x662, offset: 0x8530E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwup', symObjAddr: 0xCCC, symBinAddr: 0x14890, symSize: 0x4 }
+  - { offsetInCU: 0x676, offset: 0x85322, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwui', symObjAddr: 0xCD0, symBinAddr: 0x14894, symSize: 0x4 }
+  - { offsetInCU: 0x68A, offset: 0x85336, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOMa', symObjAddr: 0xCD4, symBinAddr: 0x14898, symSize: 0x10 }
+  - { offsetInCU: 0x712, offset: 0x853BE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP7_domainSSvgTW', symObjAddr: 0x3D8, symBinAddr: 0x13FA8, symSize: 0x4 }
+  - { offsetInCU: 0x72E, offset: 0x853DA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP5_codeSivgTW', symObjAddr: 0x3DC, symBinAddr: 0x13FAC, symSize: 0x4 }
+  - { offsetInCU: 0x74A, offset: 0x853F6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP9_userInfoyXlSgvgTW', symObjAddr: 0x3E0, symBinAddr: 0x13FB0, symSize: 0x4 }
+  - { offsetInCU: 0x766, offset: 0x85412, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP19_getEmbeddedNSErroryXlSgyFTW', symObjAddr: 0x3E4, symBinAddr: 0x13FB4, symSize: 0x4 }
+  - { offsetInCU: 0xA14, offset: 0x856C0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC18createTextureCacheSo017CVOpenGLESTextureF3RefaSgyFZ', symObjAddr: 0x0, symBinAddr: 0x13BD0, symSize: 0xA4 }
+  - { offsetInCU: 0xAAA, offset: 0x85756, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11createImageySo11CVBufferRefaSgSo022CVOpenGLESTextureCacheG0a_AFSo012CFDictionaryG0aSgs6UInt32Vs5Int32VA2p2NSitFZ', symObjAddr: 0x148, symBinAddr: 0x13D18, symSize: 0x90 }
+  - { offsetInCU: 0xC31, offset: 0x858DD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11setupRenderAA9NSCRenderCyFZ', symObjAddr: 0x2E8, symBinAddr: 0x13EB8, symSize: 0x24 }
+  - { offsetInCU: 0xC7B, offset: 0x85927, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC9drawFrameyySo8AVPlayerC_So0F15ItemVideoOutputCSo6CGSizeVAA9NSCRenderCs5Int32VANSbtFZ', symObjAddr: 0x334, symBinAddr: 0x13F04, symSize: 0x4 }
+  - { offsetInCU: 0xC9D, offset: 0x85949, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11writeToFileyySo6NSDataC_SStKFZ', symObjAddr: 0x3E8, symBinAddr: 0x13FB8, symSize: 0xE8 }
+  - { offsetInCU: 0xD4D, offset: 0x859F9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCACycfC', symObjAddr: 0x62C, symBinAddr: 0x141FC, symSize: 0x20 }
+  - { offsetInCU: 0xD61, offset: 0x85A0D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCACycfc', symObjAddr: 0x64C, symBinAddr: 0x1421C, symSize: 0x30 }
+  - { offsetInCU: 0xD97, offset: 0x85A43, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCfD', symObjAddr: 0x6B8, symBinAddr: 0x14288, symSize: 0x30 }
+  - { offsetInCU: 0x27, offset: 0x85B5C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x0, symBinAddr: 0x148AC, symSize: 0x4 }
+  - { offsetInCU: 0x71, offset: 0x85BA6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZTo', symObjAddr: 0x4, symBinAddr: 0x148B0, symSize: 0x70 }
+  - { offsetInCU: 0xF6, offset: 0x85C2B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS2ftFZTo', symObjAddr: 0x78, symBinAddr: 0x14924, symSize: 0x50 }
+  - { offsetInCU: 0x191, offset: 0x85CC6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS4ftFZTo', symObjAddr: 0xCC, symBinAddr: 0x14978, symSize: 0x68 }
+  - { offsetInCU: 0x254, offset: 0x85D89, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS8ftFZTo', symObjAddr: 0x138, symBinAddr: 0x149E4, symSize: 0x98 }
+  - { offsetInCU: 0x323, offset: 0x85E58, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCACycfcTo', symObjAddr: 0x220, symBinAddr: 0x14ACC, symSize: 0x3C }
+  - { offsetInCU: 0x375, offset: 0x85EAA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCMa', symObjAddr: 0x28C, symBinAddr: 0x14B38, symSize: 0x20 }
+  - { offsetInCU: 0x4E5, offset: 0x8601A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x0, symBinAddr: 0x148AC, symSize: 0x4 }
+  - { offsetInCU: 0x51D, offset: 0x86052, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x0, symBinAddr: 0x148AC, symSize: 0x4 }
+  - { offsetInCU: 0x588, offset: 0x860BD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS2ftFZ', symObjAddr: 0x74, symBinAddr: 0x14920, symSize: 0x4 }
+  - { offsetInCU: 0x5C8, offset: 0x860FD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS2ftFZ', symObjAddr: 0x74, symBinAddr: 0x14920, symSize: 0x4 }
+  - { offsetInCU: 0x62A, offset: 0x8615F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS4ftFZ', symObjAddr: 0xC8, symBinAddr: 0x14974, symSize: 0x4 }
+  - { offsetInCU: 0x67C, offset: 0x861B1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS4ftFZ', symObjAddr: 0xC8, symBinAddr: 0x14974, symSize: 0x4 }
+  - { offsetInCU: 0x6F1, offset: 0x86226, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS8ftFZ', symObjAddr: 0x134, symBinAddr: 0x149E0, symSize: 0x4 }
+  - { offsetInCU: 0x767, offset: 0x8629C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS8ftFZ', symObjAddr: 0x134, symBinAddr: 0x149E0, symSize: 0x4 }
+  - { offsetInCU: 0x805, offset: 0x8633A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCACycfC', symObjAddr: 0x1D0, symBinAddr: 0x14A7C, symSize: 0x20 }
+  - { offsetInCU: 0x819, offset: 0x8634E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCACycfc', symObjAddr: 0x1F0, symBinAddr: 0x14A9C, symSize: 0x30 }
+  - { offsetInCU: 0x84F, offset: 0x86384, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCfD', symObjAddr: 0x25C, symBinAddr: 0x14B08, symSize: 0x30 }
+  - { offsetInCU: 0x27, offset: 0x863CE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC10texImage2Dyys5Int64V_s5Int32VA4HSpys5UInt8VGSuSo6CGSizeVSbtFZ', symObjAddr: 0x0, symBinAddr: 0x14B58, symSize: 0x14 }
+  - { offsetInCU: 0xA9, offset: 0x86450, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC10texImage2Dyys5Int64V_s5Int32VA4HSpys5UInt8VGSuSo6CGSizeVSbtFZTo', symObjAddr: 0x14, symBinAddr: 0x14B6C, symSize: 0x38 }
+  - { offsetInCU: 0x1A2, offset: 0x86549, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC13texSubImage2Dyys5Int64V_s5Int32VA5HSpys5UInt8VGSuSo6CGSizeVSbtFZTo', symObjAddr: 0x68, symBinAddr: 0x14BC0, symSize: 0x40 }
+  - { offsetInCU: 0x284, offset: 0x8662B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCACycfcTo', symObjAddr: 0x118, symBinAddr: 0x14C70, symSize: 0x3C }
+  - { offsetInCU: 0x2D6, offset: 0x8667D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCMa', symObjAddr: 0xF8, symBinAddr: 0x14C50, symSize: 0x20 }
+  - { offsetInCU: 0x480, offset: 0x86827, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC10texImage2Dyys5Int64V_s5Int32VA4HSpys5UInt8VGSuSo6CGSizeVSbtFZ', symObjAddr: 0x0, symBinAddr: 0x14B58, symSize: 0x14 }
+  - { offsetInCU: 0x5C4, offset: 0x8696B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC13texSubImage2Dyys5Int64V_s5Int32VA5HSpys5UInt8VGSuSo6CGSizeVSbtFZ', symObjAddr: 0x4C, symBinAddr: 0x14BA4, symSize: 0x1C }
+  - { offsetInCU: 0x6FA, offset: 0x86AA1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCACycfC', symObjAddr: 0xA8, symBinAddr: 0x14C00, symSize: 0x20 }
+  - { offsetInCU: 0x70E, offset: 0x86AB5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCACycfc', symObjAddr: 0xC8, symBinAddr: 0x14C20, symSize: 0x30 }
+  - { offsetInCU: 0x744, offset: 0x86AEB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCfD', symObjAddr: 0x154, symBinAddr: 0x14CAC, symSize: 0x30 }
+  - { offsetInCU: 0x61, offset: 0x86B6F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7isDirtySbvgTo', symObjAddr: 0x4, symBinAddr: 0x14CE0, symSize: 0x10 }
+  - { offsetInCU: 0x81, offset: 0x86B8F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7isDirtySbvgTo', symObjAddr: 0x4, symBinAddr: 0x14CE0, symSize: 0x10 }
+  - { offsetInCU: 0xB7, offset: 0x86BC5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7isDirtySbvsTo', symObjAddr: 0x14, symBinAddr: 0x14CF0, symSize: 0x10 }
+  - { offsetInCU: 0xD7, offset: 0x86BE5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7isDirtySbvsTo', symObjAddr: 0x14, symBinAddr: 0x14CF0, symSize: 0x10 }
+  - { offsetInCU: 0x110, offset: 0x86C1E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC6canvasAA9NSCCanvasCSgvgTo', symObjAddr: 0x24, symBinAddr: 0x14D00, symSize: 0x48 }
+  - { offsetInCU: 0x168, offset: 0x86C76, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC6canvasAA9NSCCanvasCSgvsTo', symObjAddr: 0xB4, symBinAddr: 0x14D90, symSize: 0x50 }
+  - { offsetInCU: 0x1C3, offset: 0x86CD1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC3fbos6UInt32VvgTo', symObjAddr: 0x104, symBinAddr: 0x14DE0, symSize: 0x10 }
+  - { offsetInCU: 0x1E3, offset: 0x86CF1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC3fbos6UInt32VvgTo', symObjAddr: 0x104, symBinAddr: 0x14DE0, symSize: 0x10 }
+  - { offsetInCU: 0x219, offset: 0x86D27, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC3fbos6UInt32VvsTo', symObjAddr: 0x114, symBinAddr: 0x14DF0, symSize: 0x10 }
+  - { offsetInCU: 0x239, offset: 0x86D47, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC3fbos6UInt32VvsTo', symObjAddr: 0x114, symBinAddr: 0x14DF0, symSize: 0x10 }
+  - { offsetInCU: 0x272, offset: 0x86D80, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCACycfcTo', symObjAddr: 0x1B0, symBinAddr: 0x14E8C, symSize: 0x78 }
+  - { offsetInCU: 0x2C8, offset: 0x86DD6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frameACSo6CGRectV_tcfcTo', symObjAddr: 0x2D4, symBinAddr: 0x14FB0, symSize: 0xB0 }
+  - { offsetInCU: 0x32A, offset: 0x86E38, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5coderACSgSo7NSCoderC_tcfcTo', symObjAddr: 0x43C, symBinAddr: 0x15118, symSize: 0x28 }
+  - { offsetInCU: 0x35C, offset: 0x86E6A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC12bindDrawableyyFTo', symObjAddr: 0x4E0, symBinAddr: 0x15140, symSize: 0xA0 }
+  - { offsetInCU: 0x3DD, offset: 0x86EEB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC14deleteDrawableyyFTo', symObjAddr: 0x5BC, symBinAddr: 0x151E0, symSize: 0x60 }
+  - { offsetInCU: 0x44D, offset: 0x86F5B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7glkView_6drawInySo0C0C_So6CGRectVtFTo', symObjAddr: 0x620, symBinAddr: 0x15244, symSize: 0x4C }
+  - { offsetInCU: 0x4BF, offset: 0x86FCD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frame7contextACSo6CGRectV_So11EAGLContextCtcfcTo', symObjAddr: 0x70C, symBinAddr: 0x15330, symSize: 0x34 }
+  - { offsetInCU: 0x533, offset: 0x87041, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCMa', symObjAddr: 0x190, symBinAddr: 0x14E6C, symSize: 0x20 }
+  - { offsetInCU: 0x55D, offset: 0x8706B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCfETo', symObjAddr: 0x74C, symBinAddr: 0x15370, symSize: 0x10 }
+  - { offsetInCU: 0x65B, offset: 0x87169, size: 0x8, addend: 0x0, symName: '_$sSo7GLKViewC12CanvasNativeE16snapshotWithDatayy10Foundation0F0VFTo', symObjAddr: 0xA08, symBinAddr: 0x1562C, symSize: 0x74 }
+  - { offsetInCU: 0x699, offset: 0x871A7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC7isDirtySbvgTo', symObjAddr: 0xA7C, symBinAddr: 0x156A0, symSize: 0x10 }
+  - { offsetInCU: 0x6B9, offset: 0x871C7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC7isDirtySbvgTo', symObjAddr: 0xA7C, symBinAddr: 0x156A0, symSize: 0x10 }
+  - { offsetInCU: 0x6EF, offset: 0x871FD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC7isDirtySbvsTo', symObjAddr: 0xA8C, symBinAddr: 0x156B0, symSize: 0x10 }
+  - { offsetInCU: 0x70F, offset: 0x8721D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC7isDirtySbvsTo', symObjAddr: 0xA8C, symBinAddr: 0x156B0, symSize: 0x10 }
+  - { offsetInCU: 0x748, offset: 0x87256, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC8rendererAA9NSCCanvasCSgvgTo', symObjAddr: 0xA9C, symBinAddr: 0x156C0, symSize: 0x20 }
+  - { offsetInCU: 0x7A0, offset: 0x872AE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC8rendererAA9NSCCanvasCSgvsTo', symObjAddr: 0xABC, symBinAddr: 0x156E0, symSize: 0x14 }
+  - { offsetInCU: 0x7FB, offset: 0x87309, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvgTo', symObjAddr: 0xAD0, symBinAddr: 0x156F4, symSize: 0x44 }
+  - { offsetInCU: 0x853, offset: 0x87361, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvsTo', symObjAddr: 0xB58, symBinAddr: 0x1577C, symSize: 0x48 }
+  - { offsetInCU: 0x8E8, offset: 0x873F6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCACycfcTo', symObjAddr: 0xCBC, symBinAddr: 0x158E0, symSize: 0x78 }
+  - { offsetInCU: 0x93E, offset: 0x8744C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5frameACSo6CGRectV_tcfcTo', symObjAddr: 0xE34, symBinAddr: 0x15A58, symSize: 0xB0 }
+  - { offsetInCU: 0x9A0, offset: 0x874AE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5coderACSgSo7NSCoderC_tcfcTo', symObjAddr: 0xF90, symBinAddr: 0x15BB4, symSize: 0x28 }
+  - { offsetInCU: 0x9D2, offset: 0x874E0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC11deviceScaleSfyFTo', symObjAddr: 0xFB8, symBinAddr: 0x15BDC, symSize: 0xB8 }
+  - { offsetInCU: 0xA53, offset: 0x87561, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC4drawyySo6CGRectVFTo', symObjAddr: 0x1074, symBinAddr: 0x15C94, symSize: 0x28 }
+  - { offsetInCU: 0xAB1, offset: 0x875BF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCfETo', symObjAddr: 0x10D8, symBinAddr: 0x15CF8, symSize: 0x10 }
+  - { offsetInCU: 0xC63, offset: 0x87771, size: 0x8, addend: 0x0, symName: '_$ss22_ContiguousArrayBufferV19_uninitializedCount15minimumCapacityAByxGSi_SitcfC12CanvasNative15NSCTouchHandlerC7PointerV_Tgm5', symObjAddr: 0x130C, symBinAddr: 0x15E78, symSize: 0x80 }
+  - { offsetInCU: 0xCE6, offset: 0x877F4, size: 0x8, addend: 0x0, symName: '_$ss22_ContiguousArrayBufferV19_uninitializedCount15minimumCapacityAByxGSi_SitcfCs5UInt8V_Tgm5', symObjAddr: 0x140C, symBinAddr: 0x15EF8, symSize: 0x6C }
+  - { offsetInCU: 0xD6A, offset: 0x87878, size: 0x8, addend: 0x0, symName: '_$s10Foundation4DataV15_RepresentationOWOy', symObjAddr: 0x1630, symBinAddr: 0x1611C, symSize: 0x44 }
+  - { offsetInCU: 0xD7E, offset: 0x8788C, size: 0x8, addend: 0x0, symName: '_$s10Foundation4DataV15_RepresentationOWOe', symObjAddr: 0x1674, symBinAddr: 0x16160, symSize: 0x44 }
+  - { offsetInCU: 0xD92, offset: 0x878A0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCMa', symObjAddr: 0x16B8, symBinAddr: 0x161A4, symSize: 0x20 }
+  - { offsetInCU: 0xE6C, offset: 0x8797A, size: 0x8, addend: 0x0, symName: '_$sSaySayxGqd__c7ElementQyd__RszSTRd__lufCs5UInt8V_10Foundation4DataVTgm5Tf4g_n', symObjAddr: 0x14FC, symBinAddr: 0x15FE8, symSize: 0x124 }
+  - { offsetInCU: 0x112B, offset: 0x87C39, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC6canvasAA9NSCCanvasCSgvg', symObjAddr: 0x6C, symBinAddr: 0x14D48, symSize: 0x48 }
+  - { offsetInCU: 0x11A8, offset: 0x87CB6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCACycfc', symObjAddr: 0x124, symBinAddr: 0x14E00, symSize: 0x6C }
+  - { offsetInCU: 0x11EF, offset: 0x87CFD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frameACSo6CGRectV_tcfc', symObjAddr: 0x228, symBinAddr: 0x14F04, symSize: 0xAC }
+  - { offsetInCU: 0x1253, offset: 0x87D61, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5coderACSgSo7NSCoderC_tcfc', symObjAddr: 0x384, symBinAddr: 0x15060, symSize: 0xB8 }
+  - { offsetInCU: 0x12DE, offset: 0x87DEC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7glkView_6drawInySo0C0C_So6CGRectVtF', symObjAddr: 0x61C, symBinAddr: 0x15240, symSize: 0x4 }
+  - { offsetInCU: 0x12FF, offset: 0x87E0D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frame7contextACSo6CGRectV_So11EAGLContextCtcfC', symObjAddr: 0x66C, symBinAddr: 0x15290, symSize: 0x74 }
+  - { offsetInCU: 0x1313, offset: 0x87E21, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frame7contextACSo6CGRectV_So11EAGLContextCtcfc', symObjAddr: 0x6E0, symBinAddr: 0x15304, symSize: 0x2C }
+  - { offsetInCU: 0x142C, offset: 0x87F3A, size: 0x8, addend: 0x0, symName: '_$sSo7GLKViewC12CanvasNativeE16snapshotWithDatayy10Foundation0F0VF', symObjAddr: 0x75C, symBinAddr: 0x15380, symSize: 0x2AC }
+  - { offsetInCU: 0x17D6, offset: 0x882E4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvg', symObjAddr: 0xB14, symBinAddr: 0x15738, symSize: 0x44 }
+  - { offsetInCU: 0x1815, offset: 0x88323, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvs', symObjAddr: 0xBA0, symBinAddr: 0x157C4, symSize: 0x48 }
+  - { offsetInCU: 0x183A, offset: 0x88348, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvM', symObjAddr: 0xBE8, symBinAddr: 0x1580C, symSize: 0x44 }
+  - { offsetInCU: 0x185F, offset: 0x8836D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvM.resume.0', symObjAddr: 0xC2C, symBinAddr: 0x15850, symSize: 0x4 }
+  - { offsetInCU: 0x1886, offset: 0x88394, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCACycfC', symObjAddr: 0xC30, symBinAddr: 0x15854, symSize: 0x20 }
+  - { offsetInCU: 0x189A, offset: 0x883A8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCACycfc', symObjAddr: 0xC50, symBinAddr: 0x15874, symSize: 0x6C }
+  - { offsetInCU: 0x18E1, offset: 0x883EF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5frameACSo6CGRectV_tcfc', symObjAddr: 0xD88, symBinAddr: 0x159AC, symSize: 0xAC }
+  - { offsetInCU: 0x1940, offset: 0x8844E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5coderACSgSo7NSCoderC_tcfc', symObjAddr: 0xEE4, symBinAddr: 0x15B08, symSize: 0xAC }
+  - { offsetInCU: 0x19DE, offset: 0x884EC, size: 0x8, addend: 0x0, symName: '_$ss12_ArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtF12CanvasNative15NSCTouchHandlerC7PointerV_Tg5', symObjAddr: 0x10E8, symBinAddr: 0x15D08, symSize: 0xBC }
+  - { offsetInCU: 0x1AC0, offset: 0x885CE, size: 0x8, addend: 0x0, symName: '_$ss12_ArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtFs5UInt8V_Tg5', symObjAddr: 0x1258, symBinAddr: 0x15DC4, symSize: 0xB4 }
+  - { offsetInCU: 0x1BCC, offset: 0x886DA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7glkView_6drawInySo0C0C_So6CGRectVtFTf4ddn_n', symObjAddr: 0x1478, symBinAddr: 0x15F64, symSize: 0x84 }
+  - { offsetInCU: 0x1CC5, offset: 0x887D3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC4drawyySo6CGRectVFTf4dn_n', symObjAddr: 0x16D8, symBinAddr: 0x161C4, symSize: 0x360 }
+  - { offsetInCU: 0x4F, offset: 0x88C11, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC5queue33_7ED578B0ED4B2B6F6887A622A7B49AA3LLSo012OS_dispatch_E0CvpZ', symObjAddr: 0x980, symBinAddr: 0x115E9D0, symSize: 0x0 }
+  - { offsetInCU: 0x5D, offset: 0x88C1F, size: 0x8, addend: 0x0, symName: '_$sIegh_IeyBh_TR', symObjAddr: 0x0, symBinAddr: 0x16710, symSize: 0x2C }
+  - { offsetInCU: 0x75, offset: 0x88C37, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC5queue33_7ED578B0ED4B2B6F6887A622A7B49AA3LL_WZ', symObjAddr: 0x2C, symBinAddr: 0x1673C, symSize: 0x10C }
+  - { offsetInCU: 0xBC, offset: 0x88C7E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF4SyncySbs5Int64V_So7UIImageCtFZTo', symObjAddr: 0x13C, symBinAddr: 0x1684C, symSize: 0x44 }
+  - { offsetInCU: 0x132, offset: 0x88CF4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZTo', symObjAddr: 0x3E4, symBinAddr: 0x16AF4, symSize: 0x80 }
+  - { offsetInCU: 0x191, offset: 0x88D53, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCACycfcTo', symObjAddr: 0x4B4, symBinAddr: 0x16BC4, symSize: 0x3C }
+  - { offsetInCU: 0x1E2, offset: 0x88DA4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZTf4nnnd_n', symObjAddr: 0x524, symBinAddr: 0x16C34, symSize: 0x214 }
+  - { offsetInCU: 0x261, offset: 0x88E23, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCfETo', symObjAddr: 0x520, symBinAddr: 0x16C30, symSize: 0x4 }
+  - { offsetInCU: 0x29D, offset: 0x88E5F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCMa', symObjAddr: 0x738, symBinAddr: 0x16E48, symSize: 0x20 }
+  - { offsetInCU: 0x2BC, offset: 0x88E7E, size: 0x8, addend: 0x0, symName: '_$s10ObjectiveC8ObjCBoolVIeyBy_SbIegy_TRTA', symObjAddr: 0x77C, symBinAddr: 0x16E8C, symSize: 0x14 }
+  - { offsetInCU: 0x2E5, offset: 0x88EA7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_TA', symObjAddr: 0x7BC, symBinAddr: 0x16ECC, symSize: 0xC }
+  - { offsetInCU: 0x2F9, offset: 0x88EBB, size: 0x8, addend: 0x0, symName: _block_copy_helper, symObjAddr: 0x7C8, symBinAddr: 0x16ED8, symSize: 0x10 }
+  - { offsetInCU: 0x30D, offset: 0x88ECF, size: 0x8, addend: 0x0, symName: _block_destroy_helper, symObjAddr: 0x7D8, symBinAddr: 0x16EE8, symSize: 0x8 }
+  - { offsetInCU: 0x321, offset: 0x88EE3, size: 0x8, addend: 0x0, symName: '_$sSay8Dispatch0A13WorkItemFlagsVGMa', symObjAddr: 0x860, symBinAddr: 0x16F30, symSize: 0x54 }
+  - { offsetInCU: 0x335, offset: 0x88EF7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_yyScMYccfU0_TA', symObjAddr: 0x8F0, symBinAddr: 0x16F84, symSize: 0x24 }
+  - { offsetInCU: 0x369, offset: 0x88F2B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_yyScMYccfU_TA', symObjAddr: 0x938, symBinAddr: 0x16FCC, symSize: 0x24 }
+  - { offsetInCU: 0x4FE, offset: 0x890C0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF4SyncySbs5Int64V_So7UIImageCtFZ', symObjAddr: 0x138, symBinAddr: 0x16848, symSize: 0x4 }
+  - { offsetInCU: 0x52C, offset: 0x890EE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF4SyncySbs5Int64V_So7UIImageCtFZ', symObjAddr: 0x138, symBinAddr: 0x16848, symSize: 0x4 }
+  - { offsetInCU: 0x58B, offset: 0x8914D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZ', symObjAddr: 0x180, symBinAddr: 0x16890, symSize: 0x4 }
+  - { offsetInCU: 0x59F, offset: 0x89161, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_', symObjAddr: 0x184, symBinAddr: 0x16894, symSize: 0x260 }
+  - { offsetInCU: 0x678, offset: 0x8923A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCACycfC', symObjAddr: 0x464, symBinAddr: 0x16B74, symSize: 0x20 }
+  - { offsetInCU: 0x68C, offset: 0x8924E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCACycfc', symObjAddr: 0x484, symBinAddr: 0x16B94, symSize: 0x30 }
+  - { offsetInCU: 0x6C2, offset: 0x89284, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCfD', symObjAddr: 0x4F0, symBinAddr: 0x16C00, symSize: 0x30 }
+  - { offsetInCU: 0x27, offset: 0x8932A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfC', symObjAddr: 0x0, symBinAddr: 0x17004, symSize: 0x20 }
+  - { offsetInCU: 0x77, offset: 0x8937A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfcTo', symObjAddr: 0x70, symBinAddr: 0x17074, symSize: 0x3C }
+  - { offsetInCU: 0xC9, offset: 0x893CC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCMa', symObjAddr: 0x50, symBinAddr: 0x17054, symSize: 0x20 }
+  - { offsetInCU: 0x214, offset: 0x89517, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfC', symObjAddr: 0x0, symBinAddr: 0x17004, symSize: 0x20 }
+  - { offsetInCU: 0x228, offset: 0x8952B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfc', symObjAddr: 0x20, symBinAddr: 0x17024, symSize: 0x30 }
+  - { offsetInCU: 0x264, offset: 0x89567, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCfD', symObjAddr: 0xAC, symBinAddr: 0x170B0, symSize: 0x30 }
+  - { offsetInCU: 0x26, offset: 0x895B0, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_frombytes_vartime, symObjAddr: 0x0, symBinAddr: 0x32FE28, symSize: 0x265C }
+  - { offsetInCU: 0x40, offset: 0x895CA, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_k25519Precomp, symObjAddr: 0x9DE0, symBinAddr: 0xA29170, symSize: 0x0 }
+  - { offsetInCU: 0x92, offset: 0x8961C, size: 0x8, addend: 0x0, symName: _d, symObjAddr: 0xFDE0, symBinAddr: 0xA2F170, symSize: 0x0 }
+  - { offsetInCU: 0xF6, offset: 0x89680, size: 0x8, addend: 0x0, symName: _sqrtm1, symObjAddr: 0xFE08, symBinAddr: 0xA2F198, symSize: 0x0 }
+  - { offsetInCU: 0x10C, offset: 0x89696, size: 0x8, addend: 0x0, symName: _d2, symObjAddr: 0x10210, symBinAddr: 0xA2F5A0, symSize: 0x0 }
+  - { offsetInCU: 0x123, offset: 0x896AD, size: 0x8, addend: 0x0, symName: _Bi, symObjAddr: 0xFE50, symBinAddr: 0xA2F1E0, symSize: 0x0 }
+  - { offsetInCU: 0x9C2, offset: 0x89F4C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_frombytes_vartime, symObjAddr: 0x0, symBinAddr: 0x32FE28, symSize: 0x265C }
+  - { offsetInCU: 0x45CD, offset: 0x8DB57, size: 0x8, addend: 0x0, symName: _fe_frombytes, symObjAddr: 0x265C, symBinAddr: 0x332484, symSize: 0x134 }
+  - { offsetInCU: 0x46F3, offset: 0x8DC7D, size: 0x8, addend: 0x0, symName: _fe_mul_impl, symObjAddr: 0x9918, symBinAddr: 0x339740, symSize: 0x21C }
+  - { offsetInCU: 0x4922, offset: 0x8DEAC, size: 0x8, addend: 0x0, symName: _fe_tobytes, symObjAddr: 0x4FDC, symBinAddr: 0x334E04, symSize: 0x1B8 }
+  - { offsetInCU: 0x530F, offset: 0x8E899, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_scalarmult_base, symObjAddr: 0x2790, symBinAddr: 0x3325B8, symSize: 0x5BC }
+  - { offsetInCU: 0x5F72, offset: 0x8F4FC, size: 0x8, addend: 0x0, symName: _table_select, symObjAddr: 0x2D4C, symBinAddr: 0x332B74, symSize: 0x7F8 }
+  - { offsetInCU: 0x642A, offset: 0x8F9B4, size: 0x8, addend: 0x0, symName: _ge_madd, symObjAddr: 0x3544, symBinAddr: 0x33336C, symSize: 0x208 }
+  - { offsetInCU: 0x69F8, offset: 0x8FF82, size: 0x8, addend: 0x0, symName: _ge_p2_dbl, symObjAddr: 0x374C, symBinAddr: 0x333574, symSize: 0x7B0 }
+  - { offsetInCU: 0x77D8, offset: 0x90D62, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_sc_reduce, symObjAddr: 0x3EFC, symBinAddr: 0x333D24, symSize: 0x634 }
+  - { offsetInCU: 0x8199, offset: 0x91723, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_scalar_mult_generic_masked, symObjAddr: 0x4530, symBinAddr: 0x334358, symSize: 0xAAC }
+  - { offsetInCU: 0x956A, offset: 0x92AF4, size: 0x8, addend: 0x0, symName: _fe_loose_invert, symObjAddr: 0x5298, symBinAddr: 0x3350C0, symSize: 0x23F8 }
+  - { offsetInCU: 0xCABB, offset: 0x96045, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_public_from_private_generic_masked, symObjAddr: 0x5194, symBinAddr: 0x334FBC, symSize: 0x104 }
+  - { offsetInCU: 0xCD03, offset: 0x9628D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_invert, symObjAddr: 0x7690, symBinAddr: 0x3374B8, symSize: 0x30 }
+  - { offsetInCU: 0xCDF4, offset: 0x9637E, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_isnegative, symObjAddr: 0x76C0, symBinAddr: 0x3374E8, symSize: 0x58 }
+  - { offsetInCU: 0xCE69, offset: 0x963F3, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_mul_ttt, symObjAddr: 0x7718, symBinAddr: 0x337540, symSize: 0x4 }
+  - { offsetInCU: 0xCEB1, offset: 0x9643B, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_mul_ttt, symObjAddr: 0x7718, symBinAddr: 0x337540, symSize: 0x4 }
+  - { offsetInCU: 0xCEE0, offset: 0x9646A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_mul_ttt, symObjAddr: 0x7718, symBinAddr: 0x337540, symSize: 0x4 }
+  - { offsetInCU: 0xCF04, offset: 0x9648E, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_neg, symObjAddr: 0x771C, symBinAddr: 0x337544, symSize: 0x8C }
+  - { offsetInCU: 0xD039, offset: 0x965C3, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_tobytes, symObjAddr: 0x77A8, symBinAddr: 0x3375D0, symSize: 0x4 }
+  - { offsetInCU: 0xD072, offset: 0x965FC, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_tobytes, symObjAddr: 0x77A8, symBinAddr: 0x3375D0, symSize: 0x4 }
+  - { offsetInCU: 0xD30B, offset: 0x96895, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_double_scalarmult_vartime, symObjAddr: 0x77AC, symBinAddr: 0x3375D4, symSize: 0x1598 }
+  - { offsetInCU: 0x10654, offset: 0x99BDE, size: 0x8, addend: 0x0, symName: _x25519_ge_add, symObjAddr: 0x9B34, symBinAddr: 0x33995C, symSize: 0x218 }
+  - { offsetInCU: 0x10C86, offset: 0x9A210, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_sc_mask, symObjAddr: 0x8D44, symBinAddr: 0x338B6C, symSize: 0x20 }
+  - { offsetInCU: 0x11123, offset: 0x9A6AD, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_sc_muladd, symObjAddr: 0x8D64, symBinAddr: 0x338B8C, symSize: 0xBB4 }
+  - { offsetInCU: 0x26, offset: 0x9B490, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_from_montgomery_in_place, symObjAddr: 0x0, symBinAddr: 0x339B74, symSize: 0x1F4 }
+  - { offsetInCU: 0x1D2, offset: 0x9B63C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_from_montgomery_in_place, symObjAddr: 0x0, symBinAddr: 0x339B74, symSize: 0x1F4 }
+  - { offsetInCU: 0x26, offset: 0x9B8D7, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_neg_inv_mod_r_u64, symObjAddr: 0x0, symBinAddr: 0x339D68, symSize: 0x3C }
+  - { offsetInCU: 0x34, offset: 0x9B8E5, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_neg_inv_mod_r_u64, symObjAddr: 0x0, symBinAddr: 0x339D68, symSize: 0x3C }
+  - { offsetInCU: 0x26, offset: 0x9B9F5, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_little_endian_bytes_from_scalar, symObjAddr: 0x0, symBinAddr: 0x339DA4, symSize: 0x98 }
+  - { offsetInCU: 0x34, offset: 0x9BA03, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_little_endian_bytes_from_scalar, symObjAddr: 0x0, symBinAddr: 0x339DA4, symSize: 0x98 }
+  - { offsetInCU: 0x86, offset: 0x9BB66, size: 0x8, addend: 0x0, symName: _Q_N0, symObjAddr: 0x1100, symBinAddr: 0xA2F650, symSize: 0x0 }
+  - { offsetInCU: 0xB8, offset: 0x9BB98, size: 0x8, addend: 0x0, symName: _Q, symObjAddr: 0x1090, symBinAddr: 0xA2F5E0, symSize: 0x0 }
+  - { offsetInCU: 0xDA, offset: 0x9BBBA, size: 0x8, addend: 0x0, symName: _N, symObjAddr: 0x10C0, symBinAddr: 0xA2F610, symSize: 0x0 }
+  - { offsetInCU: 0xF0, offset: 0x9BBD0, size: 0x8, addend: 0x0, symName: _N_N0, symObjAddr: 0x10F0, symBinAddr: 0xA2F640, symSize: 0x0 }
+  - { offsetInCU: 0x3B7, offset: 0x9BE97, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_elem_mul_mont, symObjAddr: 0x100, symBinAddr: 0x339E3C, symSize: 0x18 }
+  - { offsetInCU: 0x3FB, offset: 0x9BEDB, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_elem_mul_mont, symObjAddr: 0x100, symBinAddr: 0x339E3C, symSize: 0x18 }
+  - { offsetInCU: 0x594, offset: 0x9C074, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_scalar_mul_mont, symObjAddr: 0x1F8, symBinAddr: 0x339E54, symSize: 0x18 }
+  - { offsetInCU: 0x63F, offset: 0x9C11F, size: 0x8, addend: 0x0, symName: _nistz384_point_double, symObjAddr: 0x290, symBinAddr: 0x339E6C, symSize: 0x320 }
+  - { offsetInCU: 0x1199, offset: 0x9CC79, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_point_add, symObjAddr: 0x5B0, symBinAddr: 0x33A18C, symSize: 0xAC }
+  - { offsetInCU: 0x148F, offset: 0x9CF6F, size: 0x8, addend: 0x0, symName: _nistz384_point_add, symObjAddr: 0x65C, symBinAddr: 0x33A238, symSize: 0x500 }
+  - { offsetInCU: 0x268C, offset: 0x9E16C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_point_mul, symObjAddr: 0xB5C, symBinAddr: 0x33A738, symSize: 0x2C8 }
+  - { offsetInCU: 0x2CDB, offset: 0x9E7BB, size: 0x8, addend: 0x0, symName: _p384_point_select_w5, symObjAddr: 0xE24, symBinAddr: 0x33AA00, symSize: 0xF4 }
+  - { offsetInCU: 0x2EED, offset: 0x9E9CD, size: 0x8, addend: 0x0, symName: _add_precomputed_w5, symObjAddr: 0xF18, symBinAddr: 0x33AAF4, symSize: 0x168 }
+  - { offsetInCU: 0x26, offset: 0x9ED32, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_zero, symObjAddr: 0x0, symBinAddr: 0x33AC5C, symSize: 0x38 }
+  - { offsetInCU: 0xFA, offset: 0x9EE06, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_zero, symObjAddr: 0x0, symBinAddr: 0x33AC5C, symSize: 0x38 }
+  - { offsetInCU: 0x12C, offset: 0x9EE38, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_zero, symObjAddr: 0x0, symBinAddr: 0x33AC5C, symSize: 0x38 }
+  - { offsetInCU: 0x199, offset: 0x9EEA5, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_equal, symObjAddr: 0x38, symBinAddr: 0x33AC94, symSize: 0x3C }
+  - { offsetInCU: 0x1F3, offset: 0x9EEFF, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_equal, symObjAddr: 0x38, symBinAddr: 0x33AC94, symSize: 0x3C }
+  - { offsetInCU: 0x31B, offset: 0x9F027, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_equal_limb, symObjAddr: 0x74, symBinAddr: 0x33ACD0, symSize: 0x5C }
+  - { offsetInCU: 0x517, offset: 0x9F223, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_even, symObjAddr: 0xD0, symBinAddr: 0x33AD2C, symSize: 0x1C }
+  - { offsetInCU: 0x636, offset: 0x9F342, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_less_than, symObjAddr: 0xEC, symBinAddr: 0x33AD48, symSize: 0x54 }
+  - { offsetInCU: 0x6D9, offset: 0x9F3E5, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_less_than_limb, symObjAddr: 0x140, symBinAddr: 0x33AD9C, symSize: 0x4C }
+  - { offsetInCU: 0x8A7, offset: 0x9F5B3, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_reduce_once, symObjAddr: 0x18C, symBinAddr: 0x33ADE8, symSize: 0xA8 }
+  - { offsetInCU: 0x90B, offset: 0x9F617, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_reduce_once, symObjAddr: 0x18C, symBinAddr: 0x33ADE8, symSize: 0xA8 }
+  - { offsetInCU: 0xBAA, offset: 0x9F8B6, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_add_mod, symObjAddr: 0x234, symBinAddr: 0x33AE90, symSize: 0x110 }
+  - { offsetInCU: 0xC4C, offset: 0x9F958, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_add_mod, symObjAddr: 0x234, symBinAddr: 0x33AE90, symSize: 0x110 }
+  - { offsetInCU: 0xEDE, offset: 0x9FBEA, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_sub_mod, symObjAddr: 0x344, symBinAddr: 0x33AFA0, symSize: 0xB0 }
+  - { offsetInCU: 0xF5E, offset: 0x9FC6A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_sub_mod, symObjAddr: 0x344, symBinAddr: 0x33AFA0, symSize: 0xB0 }
+  - { offsetInCU: 0x10E1, offset: 0x9FDED, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_shl_mod, symObjAddr: 0x3F4, symBinAddr: 0x33B050, symSize: 0x178 }
+  - { offsetInCU: 0x13AB, offset: 0xA00B7, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_select_512_32, symObjAddr: 0x56C, symBinAddr: 0x33B1C8, symSize: 0x1F4 }
+  - { offsetInCU: 0x1500, offset: 0xA020C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_window5_split_window, symObjAddr: 0x760, symBinAddr: 0x33B3BC, symSize: 0x18 }
+  - { offsetInCU: 0x1567, offset: 0xA0273, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_window5_unsplit_window, symObjAddr: 0x778, symBinAddr: 0x33B3D4, symSize: 0xC }
+  - { offsetInCU: 0x15A0, offset: 0xA02AC, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMB_shr, symObjAddr: 0x784, symBinAddr: 0x33B3E0, symSize: 0x8 }
+  - { offsetInCU: 0x1624, offset: 0xA0330, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_limbs_mul_add_limb, symObjAddr: 0x78C, symBinAddr: 0x33B3E8, symSize: 0x3C }
+  - { offsetInCU: 0x26, offset: 0xA04E3, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_CRYPTO_memcmp, symObjAddr: 0x0, symBinAddr: 0x33B424, symSize: 0x170 }
+  - { offsetInCU: 0x34, offset: 0xA04F1, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_CRYPTO_memcmp, symObjAddr: 0x0, symBinAddr: 0x33B424, symSize: 0x170 }
+  - { offsetInCU: 0x34, offset: 0xA05F7, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_OPENSSL_armcap_P, symObjAddr: 0x374, symBinAddr: 0x1165D10, symSize: 0x0 }
+  - { offsetInCU: 0x26, offset: 0xA0639, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul, symObjAddr: 0x0, symBinAddr: 0x33B594, symSize: 0x388 }
+  - { offsetInCU: 0x76, offset: 0xA0689, size: 0x8, addend: 0x0, symName: _ecp_nistz256_precomputed, symObjAddr: 0x1000, symBinAddr: 0xA30000, symSize: 0x0 }
+  - { offsetInCU: 0xFA, offset: 0xA070D, size: 0x8, addend: 0x0, symName: _ONE, symObjAddr: 0x26000, symBinAddr: 0xA55000, symSize: 0x0 }
+  - { offsetInCU: 0x35B, offset: 0xA096E, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul, symObjAddr: 0x0, symBinAddr: 0x33B594, symSize: 0x388 }
+  - { offsetInCU: 0xC66, offset: 0xA1279, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul_base, symObjAddr: 0x388, symBinAddr: 0x33B91C, symSize: 0x204 }
+  - { offsetInCU: 0x1171, offset: 0xA1784, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul_base_vartime, symObjAddr: 0x58C, symBinAddr: 0x33BB20, symSize: 0x1BC }
+  - { offsetInCU: 0x10, offset: 0xA1B59, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_set_encrypt_key, symObjAddr: 0x0, symBinAddr: 0x33BCE0, symSize: 0x1A0 }
+  - { offsetInCU: 0x50, offset: 0xA1B99, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_set_encrypt_key, symObjAddr: 0x0, symBinAddr: 0x33BCE0, symSize: 0x1A0 }
+  - { offsetInCU: 0x5E, offset: 0xA1BA7, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_encrypt, symObjAddr: 0x1A0, symBinAddr: 0x33BE80, symSize: 0x60 }
+  - { offsetInCU: 0x81, offset: 0xA1BCA, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_ctr32_encrypt_blocks, symObjAddr: 0x200, symBinAddr: 0x33BEE0, symSize: 0x288 }
+  - { offsetInCU: 0x10, offset: 0xA1BBB, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_init_clmul, symObjAddr: 0x0, symBinAddr: 0x33C170, symSize: 0x130 }
+  - { offsetInCU: 0x48, offset: 0xA1BF3, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_init_clmul, symObjAddr: 0x0, symBinAddr: 0x33C170, symSize: 0x130 }
+  - { offsetInCU: 0x5F, offset: 0xA1C0A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_gmult_clmul, symObjAddr: 0x130, symBinAddr: 0x33C2A0, symSize: 0x70 }
+  - { offsetInCU: 0x75, offset: 0xA1C20, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_ghash_clmul, symObjAddr: 0x1A0, symBinAddr: 0x33C310, symSize: 0x160 }
+  - { offsetInCU: 0x7A, offset: 0xA1C25, size: 0x8, addend: 0x0, symName: gcm_ghash_v8_4x, symObjAddr: 0x300, symBinAddr: 0x33C470, symSize: 0x378 }
+  - { offsetInCU: 0x10, offset: 0xA1C33, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ChaCha20_ctr32, symObjAddr: 0x0, symBinAddr: 0x33C800, symSize: 0x3A0 }
+  - { offsetInCU: 0x48, offset: 0xA1C6B, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ChaCha20_ctr32, symObjAddr: 0x0, symBinAddr: 0x33C800, symSize: 0x3A0 }
+  - { offsetInCU: 0x4C, offset: 0xA1C6F, size: 0x8, addend: 0x0, symName: ChaCha20_neon, symObjAddr: 0x3A0, symBinAddr: 0x33CBA0, symSize: 0x6C0 }
+  - { offsetInCU: 0x66, offset: 0xA1C89, size: 0x8, addend: 0x0, symName: ChaCha20_512_neon, symObjAddr: 0xA60, symBinAddr: 0x33D260, symSize: 0x1138 }
+  - { offsetInCU: 0x50, offset: 0xA1CD5, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_chacha20_poly1305_seal, symObjAddr: 0x140, symBinAddr: 0x33E500, symSize: 0x1180 }
+  - { offsetInCU: 0x66, offset: 0xA1CEB, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_chacha20_poly1305_open, symObjAddr: 0x12C0, symBinAddr: 0x33F680, symSize: 0x1410 }
+  - { offsetInCU: 0x10, offset: 0xA1CE1, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_mul_mont, symObjAddr: 0x0, symBinAddr: 0x340AA0, symSize: 0x240 }
+  - { offsetInCU: 0x45, offset: 0xA1D16, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_mul_mont, symObjAddr: 0x0, symBinAddr: 0x340AA0, symSize: 0x240 }
+  - { offsetInCU: 0x4D, offset: 0xA1D1E, size: 0x8, addend: 0x0, symName: __bn_sqr8x_mont, symObjAddr: 0x240, symBinAddr: 0x340CE0, symSize: 0x9E0 }
+  - { offsetInCU: 0x63, offset: 0xA1D34, size: 0x8, addend: 0x0, symName: __bn_mul4x_mont, symObjAddr: 0xC20, symBinAddr: 0x3416C0, symSize: 0x650 }
+  - { offsetInCU: 0x10, offset: 0xA1D43, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_mul_mont, symObjAddr: 0x0, symBinAddr: 0x341D20, symSize: 0x40 }
+  - { offsetInCU: 0x47, offset: 0xA1D7A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_mul_mont, symObjAddr: 0x0, symBinAddr: 0x341D20, symSize: 0x40 }
+  - { offsetInCU: 0x5D, offset: 0xA1D90, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_sqr_mont, symObjAddr: 0x40, symBinAddr: 0x341D60, symSize: 0x40 }
+  - { offsetInCU: 0x76, offset: 0xA1DA9, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ecp_nistz256_neg, symObjAddr: 0x80, symBinAddr: 0x341DA0, symSize: 0x40 }
+  - { offsetInCU: 0x81, offset: 0xA1DB4, size: 0x8, addend: 0x0, symName: __ecp_nistz256_mul_mont, symObjAddr: 0xC0, symBinAddr: 0x341DE0, symSize: 0x1E0 }
+  - { offsetInCU: 0x97, offset: 0xA1DCA, size: 0x8, addend: 0x0, symName: __ecp_nistz256_sqr_mont, symObjAddr: 0x2A0, symBinAddr: 0x341FC0, symSize: 0x170 }
+  - { offsetInCU: 0xAB, offset: 0xA1DDE, size: 0x8, addend: 0x0, symName: __ecp_nistz256_add_to, symObjAddr: 0x410, symBinAddr: 0x342130, symSize: 0x50 }
+  - { offsetInCU: 0xC3, offset: 0xA1DF6, size: 0x8, addend: 0x0, symName: __ecp_nistz256_sub_from, symObjAddr: 0x460, symBinAddr: 0x342180, symSize: 0x50 }
+  - { offsetInCU: 0xD9, offset: 0xA1E0C, size: 0x8, addend: 0x0, symName: __ecp_nistz256_sub_morf, symObjAddr: 0x4B0, symBinAddr: 0x3421D0, symSize: 0x50 }
+  - { offsetInCU: 0xEF, offset: 0xA1E22, size: 0x8, addend: 0x0, symName: __ecp_nistz256_div_by_2, symObjAddr: 0x500, symBinAddr: 0x342220, symSize: 0x60 }
+  - { offsetInCU: 0x111, offset: 0xA1E44, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_double, symObjAddr: 0x560, symBinAddr: 0x342280, symSize: 0x1E0 }
+  - { offsetInCU: 0x124, offset: 0xA1E57, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_add, symObjAddr: 0x740, symBinAddr: 0x342460, symSize: 0x360 }
+  - { offsetInCU: 0x141, offset: 0xA1E74, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_add_affine, symObjAddr: 0xAA0, symBinAddr: 0x3427C0, symSize: 0x2D0 }
+  - { offsetInCU: 0x156, offset: 0xA1E89, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_scalar_mul_mont, symObjAddr: 0xD70, symBinAddr: 0x342A90, symSize: 0x2B0 }
+  - { offsetInCU: 0x170, offset: 0xA1EA3, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_scalar_sqr_rep_mont, symObjAddr: 0x1020, symBinAddr: 0x342D40, symSize: 0x250 }
+  - { offsetInCU: 0x184, offset: 0xA1EB7, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ecp_nistz256_select_w5, symObjAddr: 0x1270, symBinAddr: 0x342F90, symSize: 0x60 }
+  - { offsetInCU: 0x19A, offset: 0xA1ECD, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ecp_nistz256_select_w7, symObjAddr: 0x12D0, symBinAddr: 0x342FF0, symSize: 0x44 }
+  - { offsetInCU: 0x10, offset: 0xA1EC3, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_gcm_enc_kernel, symObjAddr: 0x0, symBinAddr: 0x343040, symSize: 0xB90 }
+  - { offsetInCU: 0x4C, offset: 0xA1EFF, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_gcm_enc_kernel, symObjAddr: 0x0, symBinAddr: 0x343040, symSize: 0xB90 }
+  - { offsetInCU: 0x62, offset: 0xA1F15, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_gcm_dec_kernel, symObjAddr: 0xB90, symBinAddr: 0x343BD0, symSize: 0xB98 }
+  - { offsetInCU: 0x10, offset: 0xA1F0F, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha512_block_data_order, symObjAddr: 0x0, symBinAddr: 0x344780, symSize: 0xE40 }
+  - { offsetInCU: 0x51, offset: 0xA1F50, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha512_block_data_order, symObjAddr: 0x0, symBinAddr: 0x344780, symSize: 0xE40 }
+  - { offsetInCU: 0x51, offset: 0xA1F50, size: 0x8, addend: 0x0, symName: sha512_block_armv8, symObjAddr: 0xE40, symBinAddr: 0x3455C0, symSize: 0x7E0 }
+  - { offsetInCU: 0x10, offset: 0xA1F5B, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha256_block_data_order, symObjAddr: 0x0, symBinAddr: 0x345DC0, symSize: 0xE40 }
+  - { offsetInCU: 0x51, offset: 0xA1F9C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha256_block_data_order, symObjAddr: 0x0, symBinAddr: 0x345DC0, symSize: 0xE40 }
+  - { offsetInCU: 0x51, offset: 0xA1F9C, size: 0x8, addend: 0x0, symName: sha256_block_armv8, symObjAddr: 0xE40, symBinAddr: 0x346C00, symSize: 0x1F0 }
 ...
diff --git a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/CanvasNative b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/CanvasNative
index 6d66cfdc1..0eb0379c4 100755
Binary files a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/CanvasNative and b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/CanvasNative differ
diff --git a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/Headers/canvas_native.h b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/Headers/canvas_native.h
index b299e05f8..bdf2fa39e 100644
--- a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/Headers/canvas_native.h
+++ b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/Headers/canvas_native.h
@@ -8,6 +8,38 @@
 #include <stdint.h>
 #include <stdlib.h>
 
+typedef enum CanvasAddressMode {
+  /**
+   * Clamp the value to the edge of the texture
+   *
+   * -0.25 -> 0.0
+   * 1.25  -> 1.0
+   */
+  CanvasAddressModeClampToEdge = 0,
+  /**
+   * Repeat the texture in a tiling fashion
+   *
+   * -0.25 -> 0.75
+   * 1.25 -> 0.25
+   */
+  CanvasAddressModeRepeat = 1,
+  /**
+   * Repeat the texture, mirroring it every repeat
+   *
+   * -0.25 -> 0.25
+   * 1.25 -> 0.75
+   */
+  CanvasAddressModeMirrorRepeat = 2,
+  /**
+   * Clamp the value to the border of the texture
+   * Requires feature [`Features::ADDRESS_MODE_CLAMP_TO_BORDER`]
+   *
+   * -0.25 -> border
+   * 1.25 -> border
+   */
+  CanvasAddressModeClampToBorder = 3,
+} CanvasAddressMode;
+
 /**
  * ASTC block dimensions
  */
@@ -188,6 +220,12 @@ typedef enum CanvasBlendOperation {
   CanvasBlendOperationMax = 4,
 } CanvasBlendOperation;
 
+typedef enum CanvasBufferBindingType {
+  CanvasBufferBindingTypeUniform,
+  CanvasBufferBindingTypeStorage,
+  CanvasBufferBindingTypeReadOnlyStorage,
+} CanvasBufferBindingType;
+
 typedef enum CanvasCompareFunction {
   CanvasCompareFunctionNever = 1,
   CanvasCompareFunctionLess = 2,
@@ -205,6 +243,16 @@ typedef enum CanvasCullMode {
   CanvasCullModeBack,
 } CanvasCullMode;
 
+typedef enum CanvasFilterMode {
+  CanvasFilterModeNearest = 0,
+  /**
+   * Linear Interpolation
+   *
+   * This makes textures smooth but blurry when used as a mag filter.
+   */
+  CanvasFilterModeLinear = 1,
+} CanvasFilterMode;
+
 typedef enum CanvasFrontFace {
   CanvasFrontFaceCcw = 0,
   CanvasFrontFaceCw = 1,
@@ -214,6 +262,14 @@ typedef enum CanvasGPUAutoLayoutMode {
   CanvasGPUAutoLayoutModeAuto,
 } CanvasGPUAutoLayoutMode;
 
+typedef enum CanvasGPUErrorType {
+  CanvasGPUErrorTypeNone,
+  CanvasGPUErrorTypeLost,
+  CanvasGPUErrorTypeOutOfMemory,
+  CanvasGPUErrorTypeValidation,
+  CanvasGPUErrorTypeInternal,
+} CanvasGPUErrorType;
+
 typedef enum CanvasGPUPowerPreference {
   CanvasGPUPowerPreferenceNone,
   CanvasGPUPowerPreferenceLowPower,
@@ -271,6 +327,28 @@ typedef enum CanvasPrimitiveTopology {
   CanvasPrimitiveTopologyTriangleStrip = 4,
 } CanvasPrimitiveTopology;
 
+typedef enum CanvasQueryType {
+  CanvasQueryTypeOcclusion,
+  CanvasQueryTypeTimestamp,
+} CanvasQueryType;
+
+typedef enum CanvasSamplerBindingType {
+  /**
+   * The sampling result is produced based on more than a single color sample from a texture,
+   * e.g. when bilinear interpolation is enabled.
+   */
+  CanvasSamplerBindingTypeFiltering,
+  /**
+   * The sampling result is produced based on a single color sample from a texture.
+   */
+  CanvasSamplerBindingTypeNonFiltering,
+  /**
+   * Use as a comparison sampler instead of a normal sampler.
+   * For more info take a look at the analogous functionality in OpenGL: <https://www.khronos.org/opengl/wiki/Sampler_Object#Comparison_mode>.
+   */
+  CanvasSamplerBindingTypeComparison,
+} CanvasSamplerBindingType;
+
 typedef enum CanvasStencilOperation {
   CanvasStencilOperationKeep = 0,
   CanvasStencilOperationZero = 1,
@@ -282,6 +360,64 @@ typedef enum CanvasStencilOperation {
   CanvasStencilOperationDecrementWrap = 7,
 } CanvasStencilOperation;
 
+typedef enum CanvasStorageTextureAccess {
+  /**
+   * The texture can only be written in the shader and it:
+   * - may or may not be annotated with `write` (WGSL).
+   * - must be annotated with `writeonly` (GLSL).
+   *
+   * Example WGSL syntax:
+   * ```rust,ignore
+   * @group(0) @binding(0)
+   * var my_storage_image: texture_storage_2d<f32, write>;
+   * ```
+   *
+   * Example GLSL syntax:
+   * ```cpp,ignore
+   * layout(set=0, binding=0, r32f) writeonly uniform image2D myStorageImage;
+   * ```
+   */
+  CanvasStorageTextureAccessWriteOnly,
+  /**
+   * The texture can only be read in the shader and it must be annotated with `read` (WGSL) or
+   * `readonly` (GLSL).
+   *
+   * [`Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES`] must be enabled to use this access
+   * mode. This is a native-only extension.
+   *
+   * Example WGSL syntax:
+   * ```rust,ignore
+   * @group(0) @binding(0)
+   * var my_storage_image: texture_storage_2d<f32, read>;
+   * ```
+   *
+   * Example GLSL syntax:
+   * ```cpp,ignore
+   * layout(set=0, binding=0, r32f) readonly uniform image2D myStorageImage;
+   * ```
+   */
+  CanvasStorageTextureAccessReadOnly,
+  /**
+   * The texture can be both read and written in the shader and must be annotated with
+   * `read_write` in WGSL.
+   *
+   * [`Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES`] must be enabled to use this access
+   * mode.  This is a nonstandard, native-only extension.
+   *
+   * Example WGSL syntax:
+   * ```rust,ignore
+   * @group(0) @binding(0)
+   * var my_storage_image: texture_storage_2d<f32, read_write>;
+   * ```
+   *
+   * Example GLSL syntax:
+   * ```cpp,ignore
+   * layout(set=0, binding=0, r32f) uniform image2D myStorageImage;
+   * ```
+   */
+  CanvasStorageTextureAccessReadWrite,
+} CanvasStorageTextureAccess;
+
 typedef enum CanvasStoreOp {
   CanvasStoreOpDiscard = 0,
   CanvasStoreOpStore = 1,
@@ -320,6 +456,23 @@ typedef enum CanvasTextureDimension {
   CanvasTextureDimensionD3,
 } CanvasTextureDimension;
 
+typedef enum CanvasTextureSampleType {
+  CanvasTextureSampleTypeFloat,
+  CanvasTextureSampleTypeUnfilterableFloat,
+  CanvasTextureSampleTypeDepth,
+  CanvasTextureSampleTypeSint,
+  CanvasTextureSampleTypeUint,
+} CanvasTextureSampleType;
+
+typedef enum CanvasTextureViewDimension {
+  CanvasTextureViewDimensionD1,
+  CanvasTextureViewDimensionD2,
+  CanvasTextureViewDimensionD2Array,
+  CanvasTextureViewDimensionCube,
+  CanvasTextureViewDimensionCubeArray,
+  CanvasTextureViewDimensionD3,
+} CanvasTextureViewDimension;
+
 typedef enum CanvasVertexFormat {
   CanvasVertexFormatUint8x2 = 0,
   CanvasVertexFormatUint8x4 = 1,
@@ -478,10 +631,14 @@ typedef struct CanvasGPUCommandBuffer CanvasGPUCommandBuffer;
 
 typedef struct CanvasGPUCommandEncoder CanvasGPUCommandEncoder;
 
-typedef struct CanvasGPUComputePass CanvasGPUComputePass;
+typedef struct CanvasGPUComputePassEncoder CanvasGPUComputePassEncoder;
+
+typedef struct CanvasGPUComputePipeline CanvasGPUComputePipeline;
 
 typedef struct CanvasGPUDevice CanvasGPUDevice;
 
+typedef struct CanvasGPUError CanvasGPUError;
+
 typedef struct CanvasGPUPipelineLayout CanvasGPUPipelineLayout;
 
 typedef struct CanvasGPUQuerySet CanvasGPUQuerySet;
@@ -490,10 +647,14 @@ typedef struct CanvasGPUQueue CanvasGPUQueue;
 
 typedef struct CanvasGPURenderBundle CanvasGPURenderBundle;
 
-typedef struct CanvasGPURenderPass CanvasGPURenderPass;
+typedef struct CanvasGPURenderBundleEncoder CanvasGPURenderBundleEncoder;
+
+typedef struct CanvasGPURenderPassEncoder CanvasGPURenderPassEncoder;
 
 typedef struct CanvasGPURenderPipeline CanvasGPURenderPipeline;
 
+typedef struct CanvasGPUSampler CanvasGPUSampler;
+
 typedef struct CanvasGPUShaderModule CanvasGPUShaderModule;
 
 typedef struct CanvasGPUTexture CanvasGPUTexture;
@@ -726,65 +887,21 @@ typedef struct CanvasExtent3d {
   uint32_t depth_or_array_layers;
 } CanvasExtent3d;
 
-typedef enum CanvasGPUPipelineLayoutOrGPUAutoLayoutMode_Tag {
-  CanvasGPUPipelineLayoutOrGPUAutoLayoutModeLayout,
-  CanvasGPUPipelineLayoutOrGPUAutoLayoutModeAuto,
-} CanvasGPUPipelineLayoutOrGPUAutoLayoutMode_Tag;
+typedef struct CanvasBufferBindingLayout {
+  enum CanvasBufferBindingType type_;
+  bool has_dynamic_offset;
+  int64_t min_binding_size;
+} CanvasBufferBindingLayout;
 
-typedef struct CanvasGPUPipelineLayoutOrGPUAutoLayoutMode {
-  CanvasGPUPipelineLayoutOrGPUAutoLayoutMode_Tag tag;
-  union {
-    struct {
-      const struct CanvasGPUPipelineLayout *layout;
-    };
-    struct {
-      enum CanvasGPUAutoLayoutMode auto_;
-    };
-  };
-} CanvasGPUPipelineLayoutOrGPUAutoLayoutMode;
-
-typedef struct CanvasVertexAttribute {
-  enum CanvasVertexFormat format;
-  uint64_t offset;
-  uint32_t shader_location;
-} CanvasVertexAttribute;
-
-typedef struct CanvasVertexBufferLayout {
-  uint64_t array_stride;
-  enum CanvasVertexStepMode step_mode;
-  const struct CanvasVertexAttribute *attributes;
-  uintptr_t attributes_size;
-} CanvasVertexBufferLayout;
+typedef struct CanvasSamplerBindingLayout {
+  enum CanvasSamplerBindingType type_;
+} CanvasSamplerBindingLayout;
 
-typedef struct CanvasVertexState {
-  const struct CanvasGPUShaderModule *module;
-  const char *entry_point;
-  const struct CanvasConstants *constants;
-  const struct CanvasVertexBufferLayout *buffers;
-  uintptr_t buffers_size;
-} CanvasVertexState;
-
-typedef enum CanvasOptionalIndexFormat_Tag {
-  CanvasOptionalIndexFormatNone,
-  CanvasOptionalIndexFormatSome,
-} CanvasOptionalIndexFormat_Tag;
-
-typedef struct CanvasOptionalIndexFormat {
-  CanvasOptionalIndexFormat_Tag tag;
-  union {
-    struct {
-      enum CanvasIndexFormat some;
-    };
-  };
-} CanvasOptionalIndexFormat;
-
-typedef struct CanvasPrimitiveState {
-  enum CanvasPrimitiveTopology topology;
-  struct CanvasOptionalIndexFormat strip_index_format;
-  enum CanvasFrontFace front_face;
-  enum CanvasCullMode cull_mode;
-  bool unclipped_depth;
-} CanvasPrimitiveState;
+typedef struct CanvasTextureBindingLayout {
+  enum CanvasTextureSampleType sample_type;
+  enum CanvasTextureViewDimension view_dimension;
+  bool multisampled;
+} CanvasTextureBindingLayout;
 
 typedef enum CanvasGPUTextureFormat_Tag {
   /**
@@ -1237,6 +1354,151 @@ typedef struct CanvasGPUTextureFormat {
   };
 } CanvasGPUTextureFormat;
 
+typedef struct CanvasStorageTextureBindingLayout {
+  enum CanvasStorageTextureAccess access;
+  struct CanvasGPUTextureFormat format;
+  enum CanvasTextureViewDimension view_dimension;
+} CanvasStorageTextureBindingLayout;
+
+typedef enum CanvasBindingType_Tag {
+  CanvasBindingTypeBuffer,
+  CanvasBindingTypeSampler,
+  CanvasBindingTypeTexture,
+  CanvasBindingTypeStorageTexture,
+} CanvasBindingType_Tag;
+
+typedef struct CanvasBindingType {
+  CanvasBindingType_Tag tag;
+  union {
+    struct {
+      struct CanvasBufferBindingLayout buffer;
+    };
+    struct {
+      struct CanvasSamplerBindingLayout sampler;
+    };
+    struct {
+      struct CanvasTextureBindingLayout texture;
+    };
+    struct {
+      struct CanvasStorageTextureBindingLayout storage_texture;
+    };
+  };
+} CanvasBindingType;
+
+typedef struct CanvasBindGroupLayoutEntry {
+  uint32_t binding;
+  uint32_t visibility;
+  struct CanvasBindingType binding_type;
+} CanvasBindGroupLayoutEntry;
+
+typedef struct CanvasBufferBinding {
+  const struct CanvasGPUBuffer *buffer;
+  int64_t offset;
+  int64_t size;
+} CanvasBufferBinding;
+
+typedef enum CanvasBindGroupEntryResource_Tag {
+  CanvasBindGroupEntryResourceBuffer,
+  CanvasBindGroupEntryResourceSampler,
+  CanvasBindGroupEntryResourceTextureView,
+} CanvasBindGroupEntryResource_Tag;
+
+typedef struct CanvasBindGroupEntryResource {
+  CanvasBindGroupEntryResource_Tag tag;
+  union {
+    struct {
+      struct CanvasBufferBinding buffer;
+    };
+    struct {
+      const struct CanvasGPUSampler *sampler;
+    };
+    struct {
+      const struct CanvasGPUTextureView *texture_view;
+    };
+  };
+} CanvasBindGroupEntryResource;
+
+typedef struct CanvasBindGroupEntry {
+  uint32_t binding;
+  struct CanvasBindGroupEntryResource resource;
+} CanvasBindGroupEntry;
+
+typedef enum CanvasGPUPipelineLayoutOrGPUAutoLayoutMode_Tag {
+  CanvasGPUPipelineLayoutOrGPUAutoLayoutModeLayout,
+  CanvasGPUPipelineLayoutOrGPUAutoLayoutModeAuto,
+} CanvasGPUPipelineLayoutOrGPUAutoLayoutMode_Tag;
+
+typedef struct CanvasGPUPipelineLayoutOrGPUAutoLayoutMode {
+  CanvasGPUPipelineLayoutOrGPUAutoLayoutMode_Tag tag;
+  union {
+    struct {
+      const struct CanvasGPUPipelineLayout *layout;
+    };
+    struct {
+      enum CanvasGPUAutoLayoutMode auto_;
+    };
+  };
+} CanvasGPUPipelineLayoutOrGPUAutoLayoutMode;
+
+typedef struct CanvasProgrammableStage {
+  const struct CanvasGPUShaderModule *module;
+  const char *entry_point;
+  const struct CanvasConstants *constants;
+} CanvasProgrammableStage;
+
+typedef struct CanvasCreateRenderBundleEncoderDescriptor {
+  const char *label;
+  const struct CanvasGPUTextureFormat *color_formats;
+  uintptr_t color_formats_size;
+  const struct CanvasGPUTextureFormat *depth_stencil_format;
+  uint32_t sample_count;
+  bool depth_read_only;
+  bool stencil_read_only;
+} CanvasCreateRenderBundleEncoderDescriptor;
+
+typedef struct CanvasVertexAttribute {
+  enum CanvasVertexFormat format;
+  uint64_t offset;
+  uint32_t shader_location;
+} CanvasVertexAttribute;
+
+typedef struct CanvasVertexBufferLayout {
+  uint64_t array_stride;
+  enum CanvasVertexStepMode step_mode;
+  const struct CanvasVertexAttribute *attributes;
+  uintptr_t attributes_size;
+} CanvasVertexBufferLayout;
+
+typedef struct CanvasVertexState {
+  const struct CanvasGPUShaderModule *module;
+  const char *entry_point;
+  const struct CanvasConstants *constants;
+  const struct CanvasVertexBufferLayout *buffers;
+  uintptr_t buffers_size;
+} CanvasVertexState;
+
+typedef enum CanvasOptionalIndexFormat_Tag {
+  CanvasOptionalIndexFormatNone,
+  CanvasOptionalIndexFormatSome,
+} CanvasOptionalIndexFormat_Tag;
+
+typedef struct CanvasOptionalIndexFormat {
+  CanvasOptionalIndexFormat_Tag tag;
+  union {
+    struct {
+      enum CanvasIndexFormat some;
+    };
+  };
+} CanvasOptionalIndexFormat;
+
+typedef struct CanvasPrimitiveState {
+  enum CanvasPrimitiveTopology topology;
+  struct CanvasOptionalIndexFormat strip_index_format;
+  enum CanvasFrontFace front_face;
+  enum CanvasCullMode cull_mode;
+  bool unclipped_depth;
+} CanvasPrimitiveState;
+
 typedef struct CanvasStencilFaceState {
   enum CanvasCompareFunction compare;
   enum CanvasStencilOperation fail_op;
@@ -1356,6 +1618,34 @@ typedef struct CanvasCreateTextureDescriptor {
   uintptr_t view_formats_size;
 } CanvasCreateTextureDescriptor;
 
+typedef enum CanvasOptionalCompareFunction_Tag {
+  CanvasOptionalCompareFunctionNone,
+  CanvasOptionalCompareFunctionSome,
+} CanvasOptionalCompareFunction_Tag;
+
+typedef struct CanvasOptionalCompareFunction {
+  CanvasOptionalCompareFunction_Tag tag;
+  union {
+    struct {
+      enum CanvasCompareFunction some;
+    };
+  };
+} CanvasOptionalCompareFunction;
+
+typedef struct CanvasCreateSamplerDescriptor {
+  const char *label;
+  enum CanvasAddressMode address_mode_u;
+  enum CanvasAddressMode address_mode_v;
+  enum CanvasAddressMode address_mode_w;
+  enum CanvasFilterMode mag_filter;
+  enum CanvasFilterMode min_filter;
+  enum CanvasFilterMode mipmap_filter;
+  float lod_min_clamp;
+  float lod_max_clamp;
+  struct CanvasOptionalCompareFunction compare;
+  uint16_t max_anisotropy;
+} CanvasCreateSamplerDescriptor;
+
 typedef struct CanvasOrigin2d {
   /**
    *
@@ -4085,9 +4375,9 @@ void canvas_native_matrix_destroy(struct Matrix *value);
 
 void canvas_native_path_destroy(struct Path *value);
 
-struct CanvasWebGPUInstance *canvas_native_webgpu_instance_create(void);
+const struct CanvasWebGPUInstance *canvas_native_webgpu_instance_create(void);
 
-void canvas_native_webgpu_instance_destroy(struct CanvasWebGPUInstance *instance);
+void canvas_native_webgpu_instance_release(const struct CanvasWebGPUInstance *instance);
 
 void canvas_native_webgpu_request_adapter(const struct CanvasWebGPUInstance *instance,
                                           const struct CanvasGPURequestAdapterOptions *options,
@@ -4096,13 +4386,15 @@ void canvas_native_webgpu_request_adapter(const struct CanvasWebGPUInstance *ins
 
 char *canvas_native_webgpu_adapter_info_vendor(const struct CanvasGPUAdapterInfo *info);
 
-char *canvas_native_webgpu_adapter_info_architecture(const struct CanvasGPUAdapterInfo *info);
+char *canvas_native_webgpu_adapter_info_architecture(const struct CanvasGPUAdapterInfo *_info);
 
 char *canvas_native_webgpu_adapter_info_device(const struct CanvasGPUAdapterInfo *info);
 
 char *canvas_native_webgpu_adapter_info_description(const struct CanvasGPUAdapterInfo *info);
 
-void canvas_native_webgpu_adapter_info_destroy(struct CanvasGPUAdapterInfo *info);
+void canvas_native_webgpu_adapter_info_reference(const struct CanvasGPUAdapterInfo *info);
+
+void canvas_native_webgpu_adapter_info_release(const struct CanvasGPUAdapterInfo *info);
 
 struct StringBuffer *canvas_native_webgpu_adapter_get_features(const struct CanvasGPUAdapter *adapter);
 
@@ -4110,25 +4402,27 @@ bool canvas_native_webgpu_adapter_is_fallback_adapter(const struct CanvasGPUAdap
 
 struct CanvasGPUSupportedLimits *canvas_native_webgpu_adapter_get_limits(const struct CanvasGPUAdapter *adapter);
 
-struct CanvasGPUAdapterInfo *canvas_native_webgpu_request_adapter_info(struct CanvasGPUAdapter *adapter);
+const struct CanvasGPUAdapterInfo *canvas_native_webgpu_request_adapter_info(struct CanvasGPUAdapter *adapter);
 
-void canvas_native_webgpu_request_device(struct CanvasGPUAdapter *adapter,
+void canvas_native_webgpu_request_device(const struct CanvasGPUAdapter *adapter,
                                          const char *label,
                                          const char *const *required_features,
                                          uintptr_t required_features_length,
                                          const struct CanvasGPUSupportedLimits *required_limits,
-                                         void (*callback)(char*, struct CanvasGPUDevice*, void*),
+                                         void (*callback)(char*,
+                                                          const struct CanvasGPUDevice*,
+                                                          void*),
                                          void *callback_data);
 
 uint32_t canvas_native_webgpu_buffer_usage(const struct CanvasGPUBuffer *buffer);
 
 uint64_t canvas_native_webgpu_buffer_size(const struct CanvasGPUBuffer *buffer);
 
-char *canvas_native_webgpu_buffer_get_mapped_range(const struct CanvasGPUBuffer *buffer,
-                                                   int64_t offset,
-                                                   int64_t size,
-                                                   uint8_t *dst,
-                                                   uintptr_t dst_size);
+void canvas_native_webgpu_buffer_get_mapped_range(const struct CanvasGPUBuffer *buffer,
+                                                  int64_t offset,
+                                                  int64_t size,
+                                                  uint8_t *dst,
+                                                  uintptr_t dst_size);
 
 void canvas_native_webgpu_buffer_destroy(const struct CanvasGPUBuffer *buffer);
 
@@ -4141,95 +4435,173 @@ void canvas_native_webgpu_buffer_map_async(const struct CanvasGPUBuffer *buffer,
                                            void (*callback)(char*, void*),
                                            void *callback_data);
 
-struct CanvasGPUComputePass *canvas_native_webgpu_command_encoder_begin_compute_pass(struct CanvasGPUCommandEncoder *command_encoder,
-                                                                                     const struct CanvasGPUQuerySet *query_set,
-                                                                                     const char *label,
-                                                                                     int32_t beginning_of_pass_write_index,
-                                                                                     int32_t end_of_pass_write_index);
-
-struct CanvasGPURenderPass *canvas_native_webgpu_command_encoder_begin_render_pass(struct CanvasGPUCommandEncoder *command_encoder,
-                                                                                   const char *label,
-                                                                                   const struct CanvasRenderPassColorAttachment *color_attachments,
-                                                                                   uintptr_t color_attachments_size,
-                                                                                   const struct CanvasRenderPassDepthStencilAttachment *depth_stencil_attachment,
-                                                                                   const struct CanvasGPUQuerySet *occlusion_query_set,
-                                                                                   const struct CanvasGPUQuerySet *query_set,
-                                                                                   int32_t beginning_of_pass_write_index,
-                                                                                   int32_t end_of_pass_write_index);
-
-void canvas_native_webgpu_command_encoder_clear_buffer(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_reference(const struct CanvasGPUCommandEncoder *command_encoder);
+
+void canvas_native_webgpu_command_encoder_release(const struct CanvasGPUCommandEncoder *command_encoder);
+
+const struct CanvasGPUComputePassEncoder *canvas_native_webgpu_command_encoder_begin_compute_pass(const struct CanvasGPUCommandEncoder *command_encoder,
+                                                                                                  const struct CanvasGPUQuerySet *query_set,
+                                                                                                  const char *label,
+                                                                                                  int32_t beginning_of_pass_write_index,
+                                                                                                  int32_t end_of_pass_write_index);
+
+const struct CanvasGPURenderPassEncoder *canvas_native_webgpu_command_encoder_begin_render_pass(const struct CanvasGPUCommandEncoder *command_encoder,
+                                                                                                const char *label,
+                                                                                                const struct CanvasRenderPassColorAttachment *color_attachments,
+                                                                                                uintptr_t color_attachments_size,
+                                                                                                const struct CanvasRenderPassDepthStencilAttachment *depth_stencil_attachment,
+                                                                                                const struct CanvasGPUQuerySet *occlusion_query_set,
+                                                                                                const struct CanvasGPUQuerySet *query_set,
+                                                                                                int32_t beginning_of_pass_write_index,
+                                                                                                int32_t end_of_pass_write_index);
+
+void canvas_native_webgpu_command_encoder_clear_buffer(const struct CanvasGPUCommandEncoder *command_encoder,
                                                        const struct CanvasGPUBuffer *buffer,
                                                        int64_t offset,
                                                        int64_t size);
 
-void canvas_native_webgpu_command_encoder_copy_buffer_to_buffer(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_copy_buffer_to_buffer(const struct CanvasGPUCommandEncoder *command_encoder,
                                                                 const struct CanvasGPUBuffer *src,
                                                                 int64_t src_offset,
                                                                 const struct CanvasGPUBuffer *dst,
                                                                 int64_t dst_offset,
                                                                 uint64_t size);
 
-void canvas_native_webgpu_command_encoder_copy_buffer_to_texture(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_copy_buffer_to_texture(const struct CanvasGPUCommandEncoder *command_encoder,
                                                                  const struct CanvasImageCopyBuffer *src,
                                                                  const struct CanvasImageCopyTexture *dst,
                                                                  const struct CanvasExtent3d *copy_size);
 
-void canvas_native_webgpu_command_encoder_copy_texture_to_buffer(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_copy_texture_to_buffer(const struct CanvasGPUCommandEncoder *command_encoder,
                                                                  const struct CanvasImageCopyTexture *src,
                                                                  const struct CanvasImageCopyBuffer *dst,
                                                                  const struct CanvasExtent3d *copy_size);
 
-void canvas_native_webgpu_command_encoder_copy_texture_to_texture(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_copy_texture_to_texture(const struct CanvasGPUCommandEncoder *command_encoder,
                                                                   const struct CanvasImageCopyTexture *src,
                                                                   const struct CanvasImageCopyTexture *dst,
                                                                   const struct CanvasExtent3d *copy_size);
 
-struct CanvasGPUCommandBuffer *canvas_native_webgpu_command_encoder_finish(struct CanvasGPUCommandEncoder *command_encoder,
-                                                                           const char *label);
+const struct CanvasGPUCommandBuffer *canvas_native_webgpu_command_encoder_finish(const struct CanvasGPUCommandEncoder *command_encoder,
+                                                                                 const char *label);
 
-void canvas_native_webgpu_command_encoder_pop_debug_group(struct CanvasGPUCommandEncoder *command_encoder);
+void canvas_native_webgpu_command_encoder_pop_debug_group(const struct CanvasGPUCommandEncoder *command_encoder);
 
-void canvas_native_webgpu_command_encoder_push_debug_group(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_push_debug_group(const struct CanvasGPUCommandEncoder *command_encoder,
                                                            const char *label);
 
-void canvas_native_webgpu_command_encoder_resolve_query_set(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_resolve_query_set(const struct CanvasGPUCommandEncoder *command_encoder,
                                                             const struct CanvasGPUQuerySet *query_set,
                                                             uint32_t first_query,
                                                             uint32_t query_count,
                                                             struct CanvasGPUBuffer *dst,
                                                             uint64_t dst_offset);
 
-void canvas_native_webgpu_command_encoder_write_timestamp(struct CanvasGPUCommandEncoder *command_encoder,
+void canvas_native_webgpu_command_encoder_write_timestamp(const struct CanvasGPUCommandEncoder *command_encoder,
                                                           const struct CanvasGPUQuerySet *query_set,
                                                           uint32_t query_index);
 
+void canvas_native_webgpu_compute_pass_reference(const struct CanvasGPUComputePassEncoder *compute_pass);
+
+void canvas_native_webgpu_compute_pass_release(const struct CanvasGPUComputePassEncoder *compute_pass);
+
+void canvas_native_webgpu_compute_pass_dispatch_workgroups(const struct CanvasGPUComputePassEncoder *compute_pass,
+                                                           uint32_t workgroup_count_x,
+                                                           uint32_t workgroup_count_y,
+                                                           uint32_t workgroup_count_z);
+
+void canvas_native_webgpu_compute_pass_dispatch_workgroups_indirect(const struct CanvasGPUComputePassEncoder *compute_pass,
+                                                                    const struct CanvasGPUBuffer *indirect_buffer,
+                                                                    uintptr_t indirect_offset);
+
+void canvas_native_webgpu_compute_pass_end(const struct CanvasGPUComputePassEncoder *compute_pass);
+
+void canvas_native_webgpu_compute_pass_insert_debug_marker(const struct CanvasGPUComputePassEncoder *compute_pass,
+                                                           const char *label);
+
+void canvas_native_webgpu_compute_pass_pop_debug_group(const struct CanvasGPUComputePassEncoder *compute_pass);
+
+void canvas_native_webgpu_compute_pass_push_debug_group(const struct CanvasGPUComputePassEncoder *compute_pass,
+                                                        const char *label);
+
+void canvas_native_webgpu_compute_pass_set_bind_group(const struct CanvasGPUComputePassEncoder *compute_pass,
+                                                      uint32_t index,
+                                                      const struct CanvasGPUBindGroup *bind_group,
+                                                      const uint32_t *dynamic_offsets,
+                                                      uintptr_t dynamic_offsets_size,
+                                                      uintptr_t dynamic_offsets_start,
+                                                      uintptr_t dynamic_offsets_length);
+
+void canvas_native_webgpu_compute_pass_set_pipeline(struct CanvasGPUComputePassEncoder *compute_pass,
+                                                    const struct CanvasGPUComputePipeline *pipeline);
+
 struct StringBuffer *canvas_native_webgpu_device_get_features(const struct CanvasGPUDevice *device);
 
 struct CanvasGPUSupportedLimits *canvas_native_webgpu_device_get_limits(const struct CanvasGPUDevice *device);
 
-struct CanvasGPUQueue *canvas_native_webgpu_device_get_queue(const struct CanvasGPUDevice *device);
+const struct CanvasGPUQueue *canvas_native_webgpu_device_get_queue(const struct CanvasGPUDevice *device);
 
 void canvas_native_webgpu_device_set_lost_callback(const struct CanvasGPUDevice *device,
                                                    void (*callback)(int32_t, char*, void*),
-                                                   void *callback_data);
+                                                   void *userdata);
 
 void canvas_native_webgpu_device_destroy(const struct CanvasGPUDevice *device);
 
-void canvas_native_webgpu_device_destroy_destory(struct CanvasGPUDevice *device);
+void canvas_native_webgpu_device_reference(const struct CanvasGPUDevice *device);
 
-struct CanvasGPUCommandEncoder *canvas_native_webgpu_device_create_command_encoder(const struct CanvasGPUDevice *device,
-                                                                                   const char *label);
+void canvas_native_webgpu_device_release(const struct CanvasGPUDevice *device);
 
-struct CanvasGPUShaderModule *canvas_native_webgpu_device_create_shader_module(const struct CanvasGPUDevice *device,
+const struct CanvasGPUBindGroupLayout *canvas_native_webgpu_device_create_bind_group_layout(const struct CanvasGPUDevice *device,
+                                                                                            const char *label,
+                                                                                            const struct CanvasBindGroupLayoutEntry *entries,
+                                                                                            uintptr_t size);
+
+const struct CanvasGPUBindGroup *canvas_native_webgpu_device_create_bind_group(const struct CanvasGPUDevice *device,
                                                                                const char *label,
-                                                                               const char *source);
+                                                                               const struct CanvasGPUBindGroupLayout *layout,
+                                                                               const struct CanvasBindGroupEntry *entries,
+                                                                               uintptr_t size);
+
+const struct CanvasGPUCommandEncoder *canvas_native_webgpu_device_create_command_encoder(const struct CanvasGPUDevice *device,
+                                                                                         const char *label);
+
+const struct CanvasGPUComputePipeline *canvas_native_webgpu_device_create_compute_pipeline(const struct CanvasGPUDevice *device,
+                                                                                           const char *label,
+                                                                                           struct CanvasGPUPipelineLayoutOrGPUAutoLayoutMode layout,
+                                                                                           const struct CanvasProgrammableStage *compute);
+
+void canvas_native_webgpu_device_create_compute_pipeline_async(const struct CanvasGPUDevice *device,
+                                                               const char *label,
+                                                               struct CanvasGPUPipelineLayoutOrGPUAutoLayoutMode layout,
+                                                               const struct CanvasProgrammableStage *compute,
+                                                               void (*callback)(const struct CanvasGPUComputePipeline*,
+                                                                                enum CanvasGPUErrorType,
+                                                                                char*,
+                                                                                void*),
+                                                               void *callback_data);
+
+const struct CanvasGPUPipelineLayout *canvas_native_webgpu_device_create_pipeline_layout(const struct CanvasGPUDevice *device,
+                                                                                         const char *label,
+                                                                                         const struct CanvasGPUBindGroupLayout *group_layouts,
+                                                                                         uintptr_t size);
+
+const struct CanvasGPUQuerySet *canvas_native_webgpu_device_create_query_set(const struct CanvasGPUDevice *device,
+                                                                             const char *label,
+                                                                             enum CanvasQueryType type_,
+                                                                             uint32_t count);
+
+const struct CanvasGPURenderBundleEncoder *canvas_native_webgpu_device_create_render_bundle_encoder(const struct CanvasGPUDevice *device,
+                                                                                                    const struct CanvasCreateRenderBundleEncoderDescriptor *descriptor);
+
+const struct CanvasGPUShaderModule *canvas_native_webgpu_device_create_shader_module(const struct CanvasGPUDevice *device,
+                                                                                     const char *label,
+                                                                                     const char *source);
 
-struct CanvasGPUBuffer *canvas_native_webgpu_device_create_buffer(const struct CanvasGPUDevice *device,
-                                                                  const char *label,
-                                                                  uint64_t size,
-                                                                  uint32_t usage,
-                                                                  bool mapped_at_creation,
-                                                                  char *error);
+const struct CanvasGPUBuffer *canvas_native_webgpu_device_create_buffer(const struct CanvasGPUDevice *device,
+                                                                        const char *label,
+                                                                        uint64_t size,
+                                                                        uint32_t usage,
+                                                                        bool mapped_at_creation);
 
 struct CanvasConstants *canvas_native_webgpu_constants_create(void);
 
@@ -4239,35 +4611,45 @@ void canvas_native_webgpu_constants_insert(struct CanvasConstants *constants,
 
 void canvas_native_webgpu_constants_destroy(struct CanvasConstants *constants);
 
-struct CanvasGPURenderPipeline *canvas_native_webgpu_device_create_render_pipeline(const struct CanvasGPUDevice *device,
-                                                                                   const struct CanvasCreateRenderPipelineDescriptor *descriptor);
+const struct CanvasGPURenderPipeline *canvas_native_webgpu_device_create_render_pipeline(const struct CanvasGPUDevice *device,
+                                                                                         const struct CanvasCreateRenderPipelineDescriptor *descriptor);
 
-struct CanvasGPUTexture *canvas_native_webgpu_device_create_texture(const struct CanvasGPUDevice *device,
-                                                                    const struct CanvasCreateTextureDescriptor *descriptor,
-                                                                    char *error);
+void canvas_native_webgpu_device_create_render_pipeline_async(const struct CanvasGPUDevice *device,
+                                                              const struct CanvasCreateRenderPipelineDescriptor *descriptor,
+                                                              void (*callback)(const struct CanvasGPURenderPipeline*,
+                                                                               enum CanvasGPUErrorType,
+                                                                               char*,
+                                                                               void*),
+                                                              void *callback_data);
 
-void canvas_native_webgpu_queue_copy_external_image_to_texture(struct CanvasGPUQueue *queue,
+const struct CanvasGPUTexture *canvas_native_webgpu_device_create_texture(const struct CanvasGPUDevice *device,
+                                                                          const struct CanvasCreateTextureDescriptor *descriptor);
+
+const struct CanvasGPUSampler *canvas_native_webgpu_device_create_sampler(const struct CanvasGPUDevice *device,
+                                                                          const struct CanvasCreateSamplerDescriptor *descriptor);
+
+void canvas_native_webgpu_queue_copy_external_image_to_texture(const struct CanvasGPUQueue *queue,
                                                                const struct CanvasImageCopyExternalImage *source,
                                                                const struct CanvasImageCopyTexture *destination,
                                                                const struct CanvasExtent3d *size);
 
-void canvas_native_webgpu_queue_on_submitted_work_done(struct CanvasGPUQueue *queue,
+void canvas_native_webgpu_queue_on_submitted_work_done(const struct CanvasGPUQueue *queue,
                                                        void (*callback)(char*, void*),
                                                        void *callback_data);
 
-void canvas_native_webgpu_queue_submit(struct CanvasGPUQueue *queue,
+void canvas_native_webgpu_queue_submit(const struct CanvasGPUQueue *queue,
                                        const struct CanvasGPUCommandBuffer *const *command_buffers,
                                        uintptr_t command_buffers_size);
 
-void canvas_native_webgpu_queue_write_buffer(struct CanvasGPUQueue *queue,
-                                             struct CanvasGPUBuffer *buffer,
+void canvas_native_webgpu_queue_write_buffer(const struct CanvasGPUQueue *queue,
+                                             const struct CanvasGPUBuffer *buffer,
                                              uint64_t buffer_offset,
                                              const uint8_t *data,
                                              uintptr_t data_size,
                                              uintptr_t data_offset,
                                              intptr_t size);
 
-void canvas_native_webgpu_queue_write_texture(struct CanvasGPUQueue *queue,
+void canvas_native_webgpu_queue_write_texture(const struct CanvasGPUQueue *queue,
                                               const struct CanvasImageCopyTexture *destination,
                                               const struct CanvasImageDataLayout *data_layout,
                                               const struct CanvasExtent3d *size,
@@ -4276,49 +4658,49 @@ void canvas_native_webgpu_queue_write_texture(struct CanvasGPUQueue *queue,
 
 struct CanvasGPUSupportedLimits *canvas_native_webgpu_create_limits(void);
 
-void canvas_native_webgpu_limits_destroy(struct CanvasGPUSupportedLimits *limits);
+void canvas_native_webgpu_limits_release(struct CanvasGPUSupportedLimits *limits);
 
-void canvas_native_webgpu_render_pass_begin_occlusion_query(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_begin_occlusion_query(const struct CanvasGPURenderPassEncoder *render_pass,
                                                             uint32_t query_index);
 
-void canvas_native_webgpu_render_pass_encoder_draw(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_encoder_draw(const struct CanvasGPURenderPassEncoder *render_pass,
                                                    uint32_t vertex_count,
                                                    uint32_t instance_count,
                                                    uint32_t first_vertex,
                                                    uint32_t first_instance);
 
-void canvas_native_webgpu_render_pass_draw_indexed(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_draw_indexed(const struct CanvasGPURenderPassEncoder *render_pass,
                                                    uint32_t index_count,
                                                    uint32_t instance_count,
                                                    uint32_t first_index,
                                                    int32_t base_vertex,
                                                    uint32_t first_instance);
 
-void canvas_native_webgpu_render_pass_draw_indexed_indirect(struct CanvasGPURenderPass *render_pass,
-                                                            struct CanvasGPUBuffer *indirect_buffer,
+void canvas_native_webgpu_render_pass_draw_indexed_indirect(const struct CanvasGPURenderPassEncoder *render_pass,
+                                                            const struct CanvasGPUBuffer *indirect_buffer,
                                                             uint64_t indirect_offset);
 
-void canvas_native_webgpu_render_pass_draw_indirect(struct CanvasGPURenderPass *render_pass,
-                                                    struct CanvasGPUBuffer *indirect_buffer,
+void canvas_native_webgpu_render_pass_draw_indirect(const struct CanvasGPURenderPassEncoder *render_pass,
+                                                    const struct CanvasGPUBuffer *indirect_buffer,
                                                     uint64_t indirect_offset);
 
-void canvas_native_webgpu_render_pass_end(struct CanvasGPURenderPass *render_pass);
+void canvas_native_webgpu_render_pass_end(const struct CanvasGPURenderPassEncoder *render_pass);
 
-void canvas_native_webgpu_render_pass_end_occlusion_query(struct CanvasGPURenderPass *render_pass);
+void canvas_native_webgpu_render_pass_end_occlusion_query(const struct CanvasGPURenderPassEncoder *render_pass);
 
-void canvas_native_webgpu_render_pass_execute_bundles(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_execute_bundles(const struct CanvasGPURenderPassEncoder *render_pass,
                                                       const struct CanvasGPURenderBundle *bundles,
                                                       uintptr_t bundles_size);
 
-void canvas_native_webgpu_render_pass_insert_debug_marker(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_insert_debug_marker(const struct CanvasGPURenderPassEncoder *render_pass,
                                                           const char *label);
 
-void canvas_native_webgpu_render_pass_pop_debug_group(struct CanvasGPURenderPass *render_pass);
+void canvas_native_webgpu_render_pass_pop_debug_group(const struct CanvasGPURenderPassEncoder *render_pass);
 
-void canvas_native_webgpu_render_pass_push_debug_group(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_push_debug_group(const struct CanvasGPURenderPassEncoder *render_pass,
                                                        const char *label);
 
-void canvas_native_webgpu_render_pass_set_bind_group(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_bind_group(const struct CanvasGPURenderPassEncoder *render_pass,
                                                      uint32_t index,
                                                      const struct CanvasGPUBindGroup *bind_group,
                                                      const uint32_t *dynamic_offsets,
@@ -4326,34 +4708,34 @@ void canvas_native_webgpu_render_pass_set_bind_group(struct CanvasGPURenderPass
                                                      uintptr_t dynamic_offsets_start,
                                                      uintptr_t dynamic_offsets_length);
 
-void canvas_native_webgpu_render_pass_set_blend_constant(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_blend_constant(const struct CanvasGPURenderPassEncoder *render_pass,
                                                          const struct CanvasColor *color);
 
-void canvas_native_webgpu_render_pass_set_index_buffer(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_index_buffer(const struct CanvasGPURenderPassEncoder *render_pass,
                                                        const struct CanvasGPUBuffer *buffer,
                                                        enum CanvasIndexFormat index_format,
                                                        int64_t offset,
                                                        int64_t size);
 
-void canvas_native_webgpu_render_pass_set_pipeline(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_pipeline(const struct CanvasGPURenderPassEncoder *render_pass,
                                                    const struct CanvasGPURenderPipeline *pipeline);
 
-void canvas_native_webgpu_render_pass_set_scissor_rect(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_scissor_rect(const struct CanvasGPURenderPassEncoder *render_pass,
                                                        uint32_t x,
                                                        uint32_t y,
                                                        uint32_t width,
                                                        uint32_t height);
 
-void canvas_native_webgpu_render_pass_set_stencil_reference(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_stencil_reference(const struct CanvasGPURenderPassEncoder *render_pass,
                                                             uint32_t reference);
 
-void canvas_native_webgpu_render_pass_set_vertex_buffer(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_vertex_buffer(const struct CanvasGPURenderPassEncoder *render_pass,
                                                         uint32_t slot,
-                                                        struct CanvasGPUBuffer *buffer,
+                                                        const struct CanvasGPUBuffer *buffer,
                                                         int64_t offset,
                                                         int64_t size);
 
-void canvas_native_webgpu_render_pass_set_viewport(struct CanvasGPURenderPass *render_pass,
+void canvas_native_webgpu_render_pass_set_viewport(const struct CanvasGPURenderPassEncoder *render_pass,
                                                    float x,
                                                    float y,
                                                    float width,
@@ -4361,73 +4743,105 @@ void canvas_native_webgpu_render_pass_set_viewport(struct CanvasGPURenderPass *r
                                                    float depth_min,
                                                    float depth_max);
 
+void canvas_native_webgpu_render_pass_reference(const struct CanvasGPURenderPassEncoder *render_pass);
+
+void canvas_native_webgpu_render_pass_release(const struct CanvasGPURenderPassEncoder *render_pass);
+
 #if defined(TARGET_OS_ANDROID)
-struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create(struct CanvasWebGPUInstance *instance,
-                                                                   void *window,
-                                                                   uint32_t width,
-                                                                   uint32_t height);
+const struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create(struct CanvasWebGPUInstance *instance,
+                                                                         void *window,
+                                                                         uint32_t width,
+                                                                         uint32_t height);
 #endif
 
 #if (defined(TARGET_OS_IOS) || defined(TARGET_OS_MACOS))
-struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create(struct CanvasWebGPUInstance *instance,
-                                                                   void *view,
-                                                                   uint32_t width,
-                                                                   uint32_t height);
+const struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create(const struct CanvasWebGPUInstance *instance,
+                                                                         void *view,
+                                                                         uint32_t width,
+                                                                         uint32_t height);
 #endif
 
 #if defined(TARGET_OS_IOS)
-struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create_uiview(struct CanvasWebGPUInstance *instance,
-                                                                          void *view,
-                                                                          uint32_t width,
-                                                                          uint32_t height);
+const struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create_uiview(const struct CanvasWebGPUInstance *instance,
+                                                                                void *view,
+                                                                                uint32_t width,
+                                                                                uint32_t height);
 #endif
 
 #if defined(TARGET_OS_MACOS)
-struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create_nsview(struct CanvasWebGPUInstance *instance,
-                                                                          void *view,
-                                                                          uint32_t width,
-                                                                          uint32_t height);
+const struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create_nsview(const struct CanvasWebGPUInstance *instance,
+                                                                                void *view,
+                                                                                uint32_t width,
+                                                                                uint32_t height);
 #endif
 
-void canvas_native_webgpu_context_configure(struct CanvasGPUCanvasContext *context,
-                                            struct CanvasGPUDevice *device,
+void canvas_native_webgpu_context_configure(const struct CanvasGPUCanvasContext *context,
+                                            const struct CanvasGPUDevice *device,
                                             const struct CanvasGPUSurfaceConfiguration *config);
 
-void canvas_native_webgpu_context_unconfigure(struct CanvasGPUCanvasContext *context,
+void canvas_native_webgpu_context_unconfigure(const struct CanvasGPUCanvasContext *context,
                                               struct CanvasGPUDevice *device,
                                               const struct CanvasGPUSurfaceConfiguration *config);
 
-struct CanvasGPUTexture *canvas_native_webgpu_context_get_current_texture(struct CanvasGPUCanvasContext *context);
+const struct CanvasGPUTexture *canvas_native_webgpu_context_get_current_texture(const struct CanvasGPUCanvasContext *context);
+
+void canvas_native_webgpu_context_present_surface(const struct CanvasGPUCanvasContext *context);
+
+void canvas_native_webgpu_context_get_capabilities(const struct CanvasGPUCanvasContext *context,
+                                                   const struct CanvasGPUAdapter *adapter);
 
 char *canvas_native_webgpu_enum_gpu_texture_to_string(struct CanvasGPUTextureFormat value);
 
 struct CanvasOptionalGPUTextureFormat canvas_native_webgpu_string_to_gpu_texture_enum(const char *format);
 
-struct CanvasGPUTextureView *canvas_native_webgpu_texture_create_texture_view(struct CanvasGPUTexture *texture,
-                                                                              const struct CanvasCreateTextureViewDescriptor *descriptor);
+void canvas_native_webgpu_texture_reference(const struct CanvasGPUTexture *texture);
+
+void canvas_native_webgpu_texture_release(const struct CanvasGPUTexture *texture);
+
+const struct CanvasGPUTextureView *canvas_native_webgpu_texture_create_texture_view(const struct CanvasGPUTexture *texture,
+                                                                                    const struct CanvasCreateTextureViewDescriptor *descriptor);
+
+uint32_t canvas_native_webgpu_texture_get_depth_or_array_layers(const struct CanvasGPUTexture *texture);
+
+uint32_t canvas_native_webgpu_texture_get_width(const struct CanvasGPUTexture *texture);
+
+uint32_t canvas_native_webgpu_texture_get_height(const struct CanvasGPUTexture *texture);
+
+enum CanvasTextureDimension canvas_native_webgpu_texture_get_dimension(const struct CanvasGPUTexture *texture);
+
+struct CanvasGPUTextureFormat canvas_native_webgpu_texture_get_format(const struct CanvasGPUTexture *texture);
+
+uint32_t canvas_native_webgpu_texture_get_usage(const struct CanvasGPUTexture *texture);
+
+char *canvas_native_webgpu_texture_get_label(const struct CanvasGPUTexture *_texture);
+
+uint32_t canvas_native_webgpu_texture_get_mip_level_count(const struct CanvasGPUTexture *texture);
+
+uint32_t canvas_native_webgpu_texture_get_sample_count(const struct CanvasGPUTexture *texture);
 
-uint32_t canvas_native_webgpu_texture_get_depth_or_array_layers(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_texture_destroy(const struct CanvasGPUTexture *texture);
 
-uint32_t canvas_native_webgpu_texture_get_width(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_texture_view_reference(const struct CanvasGPUTextureView *texture_view);
 
-uint32_t canvas_native_webgpu_texture_get_height(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_texture_view_release(const struct CanvasGPUTextureView *texture_view);
 
-enum CanvasTextureDimension canvas_native_webgpu_texture_get_dimension(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_bind_group_reference(const struct CanvasGPUBindGroup *bind_group);
 
-struct CanvasGPUTextureFormat canvas_native_webgpu_texture_get_format(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_bind_group_release(const struct CanvasGPUBindGroup *bind_group);
 
-uint32_t canvas_native_webgpu_texture_get_usage(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_bind_group_layout_reference(const struct CanvasGPUBindGroupLayout *bind_group_layout);
 
-char *canvas_native_webgpu_texture_get_label(struct CanvasGPUTexture *texture);
+void canvas_native_webgpu_bind_group_layout_release(const struct CanvasGPUBindGroupLayout *bind_group_layout);
 
-uint32_t canvas_native_webgpu_texture_get_mip_level_count(struct CanvasGPUTexture *texture);
+const struct CanvasGPUBindGroupLayout *canvas_native_webgpu_render_pipeline_get_bind_group_layout(const struct CanvasGPURenderPipeline *pipeline,
+                                                                                                  uint32_t index);
 
-uint32_t canvas_native_webgpu_texture_get_sample_count(struct CanvasGPUTexture *texture);
+enum CanvasGPUErrorType canvas_native_webgpu_error_get_type(const struct CanvasGPUError *error);
 
-char *canvas_native_webgpu_texture_destroy(struct CanvasGPUTexture *texture);
+char *canvas_native_webgpu_error_get_message(const struct CanvasGPUError *error);
 
-struct CanvasGPUBindGroupLayout *canvas_native_webgpu_render_pipeline_get_bind_group_layout(const struct CanvasGPURenderPipeline *pipeline,
-                                                                                            uint32_t index);
+const struct CanvasGPUBindGroupLayout *canvas_native_webgpu_compute_pipeline_get_bind_group_layout(const struct CanvasGPUComputePipeline *pipeline,
+                                                                                                   uint32_t index);
 
 const uint8_t *canvas_native_u8_buffer_get_bytes(const struct U8Buffer *buffer);
 
diff --git a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/_CodeSignature/CodeResources b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/_CodeSignature/CodeResources
index 8fd98f5f3..a56ebf71d 100644
--- a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/_CodeSignature/CodeResources
+++ b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/_CodeSignature/CodeResources
@@ -18,7 +18,7 @@
 		</data>
 		<key>Headers/canvas_native.h</key>
 		<data>
-		TgmoImH8H+2vDVVqe5bZeCt257c=
+		oh8BcSzpm+fp13rGJCaq0GPcTKc=
 		</data>
 		<key>Info.plist</key>
 		<data>
@@ -108,7 +108,7 @@
 		<dict>
 			<key>hash2</key>
 			<data>
-			FkM9f7fdufB6qW4q5CKhNyucqWULq3Zrsp4r2SmSsQg=
+			z6RPJP7ghdTILM/o+hbRJFkhqlzQCpSD5uQEfFdsdOo=
 			</data>
 		</dict>
 		<key>Modules/CanvasNative.swiftmodule/Project/arm64-apple-ios-simulator.swiftsourceinfo</key>
diff --git a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative
index ee02dc918..e4072665b 100644
Binary files a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative and b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/DWARF/CanvasNative differ
diff --git a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/Relocations/aarch64/CanvasNative.yml b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/Relocations/aarch64/CanvasNative.yml
index b58a94329..3e8bf013e 100644
--- a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/Relocations/aarch64/CanvasNative.yml
+++ b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/Relocations/aarch64/CanvasNative.yml
@@ -2,608 +2,608 @@
 triple:          'arm64-apple-darwin'
 binary-path:     '/Users/triniwiz/Documents/GitHub/canvas/packages/canvas/src-native/canvas-ios/dist/Release-iphonesimulator/CanvasNative.framework/CanvasNative'
 relocations:
-  - { offsetInCU: 0x34, offset: 0x7768C, size: 0x8, addend: 0x0, symName: _CanvasNativeVersionString, symObjAddr: 0x0, symBinAddr: 0x8DD000, symSize: 0x0 }
-  - { offsetInCU: 0x69, offset: 0x776C1, size: 0x8, addend: 0x0, symName: _CanvasNativeVersionNumber, symObjAddr: 0x38, symBinAddr: 0x8DD038, symSize: 0x0 }
-  - { offsetInCU: 0x3F, offset: 0x77716, size: 0x8, addend: 0x0, symName: ___swift_memcpy16_8, symObjAddr: 0x28, symBinAddr: 0x5128, symSize: 0xC }
-  - { offsetInCU: 0x53, offset: 0x7772A, size: 0x8, addend: 0x0, symName: ___swift_noop_void_return, symObjAddr: 0x34, symBinAddr: 0x5134, symSize: 0x4 }
-  - { offsetInCU: 0x67, offset: 0x7773E, size: 0x8, addend: 0x0, symName: '_$sSo6CGSizeVwet', symObjAddr: 0x38, symBinAddr: 0x5138, symSize: 0x20 }
-  - { offsetInCU: 0x7B, offset: 0x77752, size: 0x8, addend: 0x0, symName: '_$sSo6CGSizeVwst', symObjAddr: 0x58, symBinAddr: 0x5158, symSize: 0x28 }
-  - { offsetInCU: 0x8F, offset: 0x77766, size: 0x8, addend: 0x0, symName: '_$sSo6CGRectVwCP', symObjAddr: 0x94, symBinAddr: 0x5194, symSize: 0x30 }
-  - { offsetInCU: 0xA3, offset: 0x7777A, size: 0x8, addend: 0x0, symName: ___swift_memcpy32_8, symObjAddr: 0xC4, symBinAddr: 0x51C4, symSize: 0xC }
-  - { offsetInCU: 0xB7, offset: 0x7778E, size: 0x8, addend: 0x0, symName: '_$sSo6CGRectVwet', symObjAddr: 0xD0, symBinAddr: 0x51D0, symSize: 0x20 }
-  - { offsetInCU: 0xCB, offset: 0x777A2, size: 0x8, addend: 0x0, symName: '_$sSo6CGRectVwst', symObjAddr: 0xF0, symBinAddr: 0x51F0, symSize: 0x2C }
-  - { offsetInCU: 0x4F, offset: 0x7798B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC11_WriteQueue33_05178D28796EA758448493B56DC45144LLSo011NSOperationE0CSgvpZ', symObjAddr: 0x2AE8, symBinAddr: 0x10C3D00, symSize: 0x0 }
-  - { offsetInCU: 0x69, offset: 0x779A5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10_ReadQueue33_05178D28796EA758448493B56DC45144LLSo011NSOperationE0CSgvpZ', symObjAddr: 0x2AF0, symBinAddr: 0x10C3D08, symSize: 0x0 }
-  - { offsetInCU: 0x9D, offset: 0x779D9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC19getBytesFromUIImageySo13NSMutableDataCSo0G0CFZTo', symObjAddr: 0x4, symBinAddr: 0x5294, symSize: 0x38 }
-  - { offsetInCU: 0xF3, offset: 0x77A2F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13createPatternys5Int64VAF_So7UIImageCSStFZTo', symObjAddr: 0x40, symBinAddr: 0x52D0, symSize: 0x70 }
-  - { offsetInCU: 0x144, offset: 0x77A80, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC25loadImageAssetWithContextySbs5Int64V_So7UIImageCtFZTo', symObjAddr: 0xB4, symBinAddr: 0x5344, symSize: 0x44 }
-  - { offsetInCU: 0x19F, offset: 0x77ADB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dyys5Int64V_So7UIImageCS2ftFZTo', symObjAddr: 0xFC, symBinAddr: 0x538C, symSize: 0x50 }
-  - { offsetInCU: 0x204, offset: 0x77B40, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dy2dw2dhys5Int64V_So7UIImageCS4ftFZTo', symObjAddr: 0x150, symBinAddr: 0x53E0, symSize: 0x68 }
-  - { offsetInCU: 0x27D, offset: 0x77BB9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2sx2sy2sw2sh2dx2dy2dw2dhys5Int64V_So7UIImageCS8ftFZTo', symObjAddr: 0x1BC, symBinAddr: 0x544C, symSize: 0x98 }
-  - { offsetInCU: 0x2DA, offset: 0x77C16, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23initWebGPUWithViewLayerys5Int64VAF_AFs6UInt32VAHtFZTo', symObjAddr: 0x258, symBinAddr: 0x54E8, symSize: 0x14 }
-  - { offsetInCU: 0x35C, offset: 0x77C98, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC18initWebGPUWithViewys5Int64VAF_AFs6UInt32VAHtFZTo', symObjAddr: 0x270, symBinAddr: 0x5500, symSize: 0x14 }
-  - { offsetInCU: 0x40B, offset: 0x77D47, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14initGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbtFZTo', symObjAddr: 0x2C8, symBinAddr: 0x5558, symSize: 0x50 }
-  - { offsetInCU: 0x4DC, offset: 0x77E18, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC20initSharedGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbAFtFZTo', symObjAddr: 0x364, symBinAddr: 0x55F4, symSize: 0x58 }
-  - { offsetInCU: 0x5B6, offset: 0x77EF2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC24initGLWithWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbtFZTo', symObjAddr: 0x404, symBinAddr: 0x5694, symSize: 0x58 }
-  - { offsetInCU: 0x695, offset: 0x77FD1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC26initSharedGLWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbAFtFZTo', symObjAddr: 0x4AC, symBinAddr: 0x573C, symSize: 0x60 }
-  - { offsetInCU: 0x741, offset: 0x7807D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15resize2DContextyys5Int64V_S2ftFZTo', symObjAddr: 0x510, symBinAddr: 0x57A0, symSize: 0x8 }
-  - { offsetInCU: 0x7AA, offset: 0x780E6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14flush2DContextyys5Int64VFZTo', symObjAddr: 0x51C, symBinAddr: 0x57AC, symSize: 0x8 }
-  - { offsetInCU: 0x801, offset: 0x7813D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC7flushGLySbs5Int64VFZTo', symObjAddr: 0x538, symBinAddr: 0x57C8, symSize: 0x8 }
-  - { offsetInCU: 0x858, offset: 0x78194, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9releaseGLyys5Int64VFZTo', symObjAddr: 0x544, symBinAddr: 0x57D4, symSize: 0x8 }
-  - { offsetInCU: 0x8AF, offset: 0x781EB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC12getGLPointerys5Int64VAFFZTo', symObjAddr: 0x550, symBinAddr: 0x57E0, symSize: 0x8 }
-  - { offsetInCU: 0x906, offset: 0x78242, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC16releaseGLPointeryys5Int64VFZTo', symObjAddr: 0x55C, symBinAddr: 0x57EC, symSize: 0x8 }
-  - { offsetInCU: 0x985, offset: 0x782C1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15create2DContextys5Int64VAF_s5Int32VAHSbSfA2HSfAHtFZTo', symObjAddr: 0x56C, symBinAddr: 0x57FC, symSize: 0x24 }
-  - { offsetInCU: 0xA36, offset: 0x78372, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23updateGLSurfaceWithViewyys5Int64V_s5Int32VAhFtFZTo', symObjAddr: 0x594, symBinAddr: 0x5824, symSize: 0x14 }
-  - { offsetInCU: 0xAA9, offset: 0x783E5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC6test2Dyys5Int64VFZTo', symObjAddr: 0x5AC, symBinAddr: 0x583C, symSize: 0x8 }
-  - { offsetInCU: 0xB00, offset: 0x7843C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13testToDataURLySSs5Int64VFZTo', symObjAddr: 0x60C, symBinAddr: 0x589C, symSize: 0x74 }
-  - { offsetInCU: 0xB8B, offset: 0x784C7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZTo', symObjAddr: 0x814, symBinAddr: 0x5AA4, symSize: 0xA0 }
-  - { offsetInCU: 0xBDC, offset: 0x78518, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZTo', symObjAddr: 0xB1C, symBinAddr: 0x5DAC, symSize: 0x98 }
-  - { offsetInCU: 0xC2D, offset: 0x78569, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZTo', symObjAddr: 0xE70, symBinAddr: 0x6100, symSize: 0x98 }
-  - { offsetInCU: 0xC89, offset: 0x785C5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZTo', symObjAddr: 0x1298, symBinAddr: 0x6528, symSize: 0xD8 }
-  - { offsetInCU: 0xCD1, offset: 0x7860D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC32getPixelsPerInchForCurrentDeviceSSyFZTo', symObjAddr: 0x1374, symBinAddr: 0x6604, symSize: 0x34 }
-  - { offsetInCU: 0xD31, offset: 0x7866D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCACycfcTo', symObjAddr: 0x13F8, symBinAddr: 0x6688, symSize: 0x3C }
-  - { offsetInCU: 0xD82, offset: 0x786BE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC19getBytesFromUIImageySo13NSMutableDataCSo0G0CFZTf4nd_n', symObjAddr: 0x1468, symBinAddr: 0x66F8, symSize: 0x2AC }
-  - { offsetInCU: 0xFB6, offset: 0x788F2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13createPatternys5Int64VAF_So7UIImageCSStFZTf4nnnd_n', symObjAddr: 0x1714, symBinAddr: 0x69A4, symSize: 0x264 }
-  - { offsetInCU: 0x11B0, offset: 0x78AEC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC25loadImageAssetWithContextySbs5Int64V_So7UIImageCtFZTf4nnd_n', symObjAddr: 0x1978, symBinAddr: 0x6C08, symSize: 0xEC }
-  - { offsetInCU: 0x12AD, offset: 0x78BE9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dyys5Int64V_So7UIImageCS2ftFZTf4nnnnd_n', symObjAddr: 0x1A64, symBinAddr: 0x6CF4, symSize: 0x1B4 }
-  - { offsetInCU: 0x1422, offset: 0x78D5E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dy2dw2dhys5Int64V_So7UIImageCS4ftFZTf4nnnnnnd_n', symObjAddr: 0x1C18, symBinAddr: 0x6EA8, symSize: 0x1CC }
-  - { offsetInCU: 0x15B7, offset: 0x78EF3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2sx2sy2sw2sh2dx2dy2dw2dhys5Int64V_So7UIImageCS8ftFZTf4nnnnnnnnnnd_n', symObjAddr: 0x1DE4, symBinAddr: 0x7074, symSize: 0x1E0 }
-  - { offsetInCU: 0x17A3, offset: 0x790DF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZTf4nnnd_n', symObjAddr: 0x1FC4, symBinAddr: 0x7254, symSize: 0x1B4 }
-  - { offsetInCU: 0x186D, offset: 0x791A9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZTf4nnnnd_n', symObjAddr: 0x231C, symBinAddr: 0x75AC, symSize: 0x1D4 }
-  - { offsetInCU: 0x194E, offset: 0x7928A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC32getPixelsPerInchForCurrentDeviceSSyFZTf4d_n', symObjAddr: 0x24F0, symBinAddr: 0x7780, symSize: 0x114 }
-  - { offsetInCU: 0x19F9, offset: 0x79335, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgACIeyByy_SSSgADIeggg_TR', symObjAddr: 0x8B4, symBinAddr: 0x5B44, symSize: 0x78 }
-  - { offsetInCU: 0x1A11, offset: 0x7934D, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgSo6NSDataCSgIeyByy_SSSgAFIeggg_TR', symObjAddr: 0xBB4, symBinAddr: 0x5E44, symSize: 0x54 }
-  - { offsetInCU: 0x1A7E, offset: 0x793BA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCfETo', symObjAddr: 0x1464, symBinAddr: 0x66F4, symSize: 0x4 }
-  - { offsetInCU: 0x1B09, offset: 0x79445, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCMa', symObjAddr: 0x2604, symBinAddr: 0x7894, symSize: 0x20 }
-  - { offsetInCU: 0x1B1D, offset: 0x79459, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgACIeyByy_SSSgADIeggg_TRTA', symObjAddr: 0x2648, symBinAddr: 0x78D8, symSize: 0x8 }
-  - { offsetInCU: 0x1B3C, offset: 0x79478, size: 0x8, addend: 0x0, symName: '_$sSo7NSErrorCSg10ObjectiveC8ObjCBoolVIeyByy_ACSbIeggy_TRTA', symObjAddr: 0x2650, symBinAddr: 0x78E0, symSize: 0x18 }
-  - { offsetInCU: 0x1B65, offset: 0x794A1, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgSo6NSDataCSgIeyByy_SSSgAFIeggg_TRTA', symObjAddr: 0x2668, symBinAddr: 0x78F8, symSize: 0x8 }
-  - { offsetInCU: 0x1B79, offset: 0x794B5, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCMa', symObjAddr: 0x2670, symBinAddr: 0x7900, symSize: 0x3C }
-  - { offsetInCU: 0x1B8D, offset: 0x794C9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZyyYbcfU_TA', symObjAddr: 0x26F0, symBinAddr: 0x7980, symSize: 0x34 }
-  - { offsetInCU: 0x1BA1, offset: 0x794DD, size: 0x8, addend: 0x0, symName: _block_copy_helper, symObjAddr: 0x2724, symBinAddr: 0x79B4, symSize: 0x10 }
-  - { offsetInCU: 0x1BB5, offset: 0x794F1, size: 0x8, addend: 0x0, symName: _block_destroy_helper, symObjAddr: 0x2734, symBinAddr: 0x79C4, symSize: 0x8 }
-  - { offsetInCU: 0x1BC9, offset: 0x79505, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZyyYbcfU_yyYbcfU0_TA', symObjAddr: 0x2760, symBinAddr: 0x79F0, symSize: 0x40 }
-  - { offsetInCU: 0x1BFD, offset: 0x79539, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZyyYbcfU_yyYbcfU0_TA', symObjAddr: 0x27E4, symBinAddr: 0x7A74, symSize: 0x40 }
-  - { offsetInCU: 0x1C3B, offset: 0x79577, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZyyYbcfU_yyYbcfU_TA', symObjAddr: 0x2824, symBinAddr: 0x7AB4, symSize: 0x28 }
-  - { offsetInCU: 0x1C6F, offset: 0x795AB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZyyYbcfU_yyYbcfU_TA', symObjAddr: 0x28A4, symBinAddr: 0x7B34, symSize: 0x3C }
-  - { offsetInCU: 0x1CA3, offset: 0x795DF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZyyYbcfU_yyYbcfU0_TA', symObjAddr: 0x290C, symBinAddr: 0x7B9C, symSize: 0x30 }
-  - { offsetInCU: 0x1CDF, offset: 0x7961B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZyyYbcfU_TA', symObjAddr: 0x2978, symBinAddr: 0x7C08, symSize: 0x10 }
-  - { offsetInCU: 0x1CF3, offset: 0x7962F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZyyYbcfU_yyYbcfU_TA', symObjAddr: 0x2988, symBinAddr: 0x7C18, symSize: 0x40 }
-  - { offsetInCU: 0x21C0, offset: 0x79AFC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC19getBytesFromUIImageySo13NSMutableDataCSo0G0CFZ', symObjAddr: 0x0, symBinAddr: 0x5290, symSize: 0x4 }
-  - { offsetInCU: 0x21DB, offset: 0x79B17, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x3C, symBinAddr: 0x52CC, symSize: 0x4 }
-  - { offsetInCU: 0x21F6, offset: 0x79B32, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC25loadImageAssetWithContextySbs5Int64V_So7UIImageCtFZ', symObjAddr: 0xB0, symBinAddr: 0x5340, symSize: 0x4 }
-  - { offsetInCU: 0x2217, offset: 0x79B53, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dyys5Int64V_So7UIImageCS2ftFZ', symObjAddr: 0xF8, symBinAddr: 0x5388, symSize: 0x4 }
-  - { offsetInCU: 0x2232, offset: 0x79B6E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dy2dw2dhys5Int64V_So7UIImageCS4ftFZ', symObjAddr: 0x14C, symBinAddr: 0x53DC, symSize: 0x4 }
-  - { offsetInCU: 0x224D, offset: 0x79B89, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2sx2sy2sw2sh2dx2dy2dw2dhys5Int64V_So7UIImageCS8ftFZ', symObjAddr: 0x1B8, symBinAddr: 0x5448, symSize: 0x4 }
-  - { offsetInCU: 0x2268, offset: 0x79BA4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23initWebGPUWithViewLayerys5Int64VAF_AFs6UInt32VAHtFZ', symObjAddr: 0x254, symBinAddr: 0x54E4, symSize: 0x4 }
-  - { offsetInCU: 0x22F6, offset: 0x79C32, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC18initWebGPUWithViewys5Int64VAF_AFs6UInt32VAHtFZ', symObjAddr: 0x26C, symBinAddr: 0x54FC, symSize: 0x4 }
-  - { offsetInCU: 0x2375, offset: 0x79CB1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14initGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbtFZ', symObjAddr: 0x284, symBinAddr: 0x5514, symSize: 0x44 }
-  - { offsetInCU: 0x24B3, offset: 0x79DEF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC20initSharedGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbAFtFZ', symObjAddr: 0x318, symBinAddr: 0x55A8, symSize: 0x4C }
-  - { offsetInCU: 0x25FC, offset: 0x79F38, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC24initGLWithWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbtFZ', symObjAddr: 0x3BC, symBinAddr: 0x564C, symSize: 0x48 }
-  - { offsetInCU: 0x2744, offset: 0x7A080, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC26initSharedGLWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbAFtFZ', symObjAddr: 0x45C, symBinAddr: 0x56EC, symSize: 0x50 }
-  - { offsetInCU: 0x28A1, offset: 0x7A1DD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15resize2DContextyys5Int64V_S2ftFZ', symObjAddr: 0x50C, symBinAddr: 0x579C, symSize: 0x4 }
-  - { offsetInCU: 0x2913, offset: 0x7A24F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14flush2DContextyys5Int64VFZ', symObjAddr: 0x518, symBinAddr: 0x57A8, symSize: 0x4 }
-  - { offsetInCU: 0x2956, offset: 0x7A292, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC7flushGLySbs5Int64VFZ', symObjAddr: 0x524, symBinAddr: 0x57B4, symSize: 0x14 }
-  - { offsetInCU: 0x299B, offset: 0x7A2D7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9releaseGLyys5Int64VFZ', symObjAddr: 0x540, symBinAddr: 0x57D0, symSize: 0x4 }
-  - { offsetInCU: 0x29DE, offset: 0x7A31A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC12getGLPointerys5Int64VAFFZ', symObjAddr: 0x54C, symBinAddr: 0x57DC, symSize: 0x4 }
-  - { offsetInCU: 0x2A21, offset: 0x7A35D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC16releaseGLPointeryys5Int64VFZ', symObjAddr: 0x558, symBinAddr: 0x57E8, symSize: 0x4 }
-  - { offsetInCU: 0x2A64, offset: 0x7A3A0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15create2DContextys5Int64VAF_s5Int32VAHSbSfA2HSfAHtFZ', symObjAddr: 0x564, symBinAddr: 0x57F4, symSize: 0x8 }
-  - { offsetInCU: 0x2B4B, offset: 0x7A487, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23updateGLSurfaceWithViewyys5Int64V_s5Int32VAhFtFZ', symObjAddr: 0x590, symBinAddr: 0x5820, symSize: 0x4 }
-  - { offsetInCU: 0x2BCA, offset: 0x7A506, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC6test2Dyys5Int64VFZ', symObjAddr: 0x5A8, symBinAddr: 0x5838, symSize: 0x4 }
-  - { offsetInCU: 0x2C0D, offset: 0x7A549, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13testToDataURLySSs5Int64VFZ', symObjAddr: 0x5B4, symBinAddr: 0x5844, symSize: 0x58 }
-  - { offsetInCU: 0x2CCE, offset: 0x7A60A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZ', symObjAddr: 0x680, symBinAddr: 0x5910, symSize: 0x4 }
-  - { offsetInCU: 0x2CE2, offset: 0x7A61E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZyyYbcfU_', symObjAddr: 0x684, symBinAddr: 0x5914, symSize: 0x190 }
-  - { offsetInCU: 0x2D82, offset: 0x7A6BE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZ', symObjAddr: 0x92C, symBinAddr: 0x5BBC, symSize: 0x2C }
-  - { offsetInCU: 0x2D96, offset: 0x7A6D2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZyyYbcfU_', symObjAddr: 0x958, symBinAddr: 0x5BE8, symSize: 0x1C4 }
-  - { offsetInCU: 0x2E80, offset: 0x7A7BC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZ', symObjAddr: 0xC08, symBinAddr: 0x5E98, symSize: 0x2C }
-  - { offsetInCU: 0x2E94, offset: 0x7A7D0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZyyYbcfU_', symObjAddr: 0xC34, symBinAddr: 0x5EC4, symSize: 0x23C }
-  - { offsetInCU: 0x2F48, offset: 0x7A884, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZ', symObjAddr: 0xF08, symBinAddr: 0x6198, symSize: 0x4 }
-  - { offsetInCU: 0x2F5C, offset: 0x7A898, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZyyYbcfU_', symObjAddr: 0xF0C, symBinAddr: 0x619C, symSize: 0x38C }
-  - { offsetInCU: 0x31F3, offset: 0x7AB2F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC32getPixelsPerInchForCurrentDeviceSSyFZ', symObjAddr: 0x1370, symBinAddr: 0x6600, symSize: 0x4 }
-  - { offsetInCU: 0x320E, offset: 0x7AB4A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCACycfC', symObjAddr: 0x13A8, symBinAddr: 0x6638, symSize: 0x20 }
-  - { offsetInCU: 0x3222, offset: 0x7AB5E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCACycfc', symObjAddr: 0x13C8, symBinAddr: 0x6658, symSize: 0x30 }
-  - { offsetInCU: 0x3258, offset: 0x7AB94, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCfD', symObjAddr: 0x1434, symBinAddr: 0x66C4, symSize: 0x30 }
-  - { offsetInCU: 0x4F, offset: 0x7ADCC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19shared_context_view33_508084857CA7D194CA72FEB80DD78002LLSo7GLKViewCvpZ', symObjAddr: 0x55B0, symBinAddr: 0x10C3D40, symSize: 0x0 }
-  - { offsetInCU: 0x69, offset: 0x7ADE6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15_shared_context33_508084857CA7D194CA72FEB80DD78002LLs5Int64VvpZ', symObjAddr: 0x55B8, symBinAddr: 0x10C3D48, symSize: 0x0 }
-  - { offsetInCU: 0x83, offset: 0x7AE00, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5storeSo19NSMutableDictionaryCvpZ', symObjAddr: 0x55C0, symBinAddr: 0x10C3D50, symSize: 0x0 }
-  - { offsetInCU: 0x9D, offset: 0x7AE1A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5views33_508084857CA7D194CA72FEB80DD78002LLSo10NSMapTableCySo8NSStringCACGvpZ', symObjAddr: 0x55C8, symBinAddr: 0x10C3D58, symSize: 0x0 }
-  - { offsetInCU: 0xAB, offset: 0x7AE28, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19shared_context_view33_508084857CA7D194CA72FEB80DD78002LL_WZ', symObjAddr: 0x0, symBinAddr: 0x7D40, symSize: 0x40 }
-  - { offsetInCU: 0xF0, offset: 0x7AE6D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5store_WZ', symObjAddr: 0x40, symBinAddr: 0x7D80, symSize: 0x30 }
-  - { offsetInCU: 0x135, offset: 0x7AEB2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5views33_508084857CA7D194CA72FEB80DD78002LL_WZ', symObjAddr: 0xA8, symBinAddr: 0x7DE8, symSize: 0x40 }
-  - { offsetInCU: 0x187, offset: 0x7AF04, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC3ptrSvSgvgTo', symObjAddr: 0x194, symBinAddr: 0x7ED4, symSize: 0x10 }
-  - { offsetInCU: 0x1A7, offset: 0x7AF24, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC3ptrSvSgvgTo', symObjAddr: 0x194, symBinAddr: 0x7ED4, symSize: 0x10 }
-  - { offsetInCU: 0x1DD, offset: 0x7AF5A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC3ptrSvSgvsTo', symObjAddr: 0x1A4, symBinAddr: 0x7EE4, symSize: 0x10 }
-  - { offsetInCU: 0x1FD, offset: 0x7AF7A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC3ptrSvSgvsTo', symObjAddr: 0x1A4, symBinAddr: 0x7EE4, symSize: 0x10 }
-  - { offsetInCU: 0x236, offset: 0x7AFB3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6mtlPtrSvSgvgTo', symObjAddr: 0x1B4, symBinAddr: 0x7EF4, symSize: 0x10 }
-  - { offsetInCU: 0x256, offset: 0x7AFD3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6mtlPtrSvSgvgTo', symObjAddr: 0x1B4, symBinAddr: 0x7EF4, symSize: 0x10 }
-  - { offsetInCU: 0x28C, offset: 0x7B009, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6mtlPtrSvSgvsTo', symObjAddr: 0x1C4, symBinAddr: 0x7F04, symSize: 0x10 }
-  - { offsetInCU: 0x2AC, offset: 0x7B029, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6mtlPtrSvSgvsTo', symObjAddr: 0x1C4, symBinAddr: 0x7F04, symSize: 0x10 }
-  - { offsetInCU: 0x2E5, offset: 0x7B062, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvgTo', symObjAddr: 0x29C, symBinAddr: 0x7FDC, symSize: 0x44 }
-  - { offsetInCU: 0x322, offset: 0x7B09F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvsTo', symObjAddr: 0x324, symBinAddr: 0x8064, symSize: 0x30 }
-  - { offsetInCU: 0x3B1, offset: 0x7B12E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8nativeGLs5Int64VvgTo', symObjAddr: 0x578, symBinAddr: 0x82B8, symSize: 0x44 }
-  - { offsetInCU: 0x409, offset: 0x7B186, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8nativeGLs5Int64VvsTo', symObjAddr: 0x600, symBinAddr: 0x8340, symSize: 0x48 }
-  - { offsetInCU: 0x464, offset: 0x7B1E1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13nativeContexts5Int64VvgTo', symObjAddr: 0x648, symBinAddr: 0x8388, symSize: 0x44 }
-  - { offsetInCU: 0x4BC, offset: 0x7B239, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13nativeContexts5Int64VvsTo', symObjAddr: 0x6D0, symBinAddr: 0x8410, symSize: 0x48 }
-  - { offsetInCU: 0x517, offset: 0x7B294, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15native2DContexts5Int64VvgTo', symObjAddr: 0x718, symBinAddr: 0x8458, symSize: 0x10 }
-  - { offsetInCU: 0x537, offset: 0x7B2B4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15native2DContexts5Int64VvgTo', symObjAddr: 0x718, symBinAddr: 0x8458, symSize: 0x10 }
-  - { offsetInCU: 0x56D, offset: 0x7B2EA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15native2DContexts5Int64VvsTo', symObjAddr: 0x728, symBinAddr: 0x8468, symSize: 0x10 }
-  - { offsetInCU: 0x58D, offset: 0x7B30A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15native2DContexts5Int64VvsTo', symObjAddr: 0x728, symBinAddr: 0x8468, symSize: 0x10 }
-  - { offsetInCU: 0x5C6, offset: 0x7B343, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7mtlViewSo7MTKViewCvgTo', symObjAddr: 0x738, symBinAddr: 0x8478, symSize: 0x10 }
-  - { offsetInCU: 0x5E6, offset: 0x7B363, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7mtlViewSo7MTKViewCvgTo', symObjAddr: 0x738, symBinAddr: 0x8478, symSize: 0x10 }
-  - { offsetInCU: 0x61E, offset: 0x7B39B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7mtlViewSo7MTKViewCvsTo', symObjAddr: 0x748, symBinAddr: 0x8488, symSize: 0x34 }
-  - { offsetInCU: 0x677, offset: 0x7B3F4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7glkViewAA0A7GLKViewCvgTo', symObjAddr: 0x77C, symBinAddr: 0x84BC, symSize: 0x10 }
-  - { offsetInCU: 0x697, offset: 0x7B414, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7glkViewAA0A7GLKViewCvgTo', symObjAddr: 0x77C, symBinAddr: 0x84BC, symSize: 0x10 }
-  - { offsetInCU: 0x6CF, offset: 0x7B44C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7glkViewAA0A7GLKViewCvsTo', symObjAddr: 0x78C, symBinAddr: 0x84CC, symSize: 0x34 }
-  - { offsetInCU: 0x728, offset: 0x7B4A5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC4is2DSbvgTo', symObjAddr: 0x7C0, symBinAddr: 0x8500, symSize: 0x10 }
-  - { offsetInCU: 0x748, offset: 0x7B4C5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC4is2DSbvgTo', symObjAddr: 0x7C0, symBinAddr: 0x8500, symSize: 0x10 }
-  - { offsetInCU: 0x77E, offset: 0x7B4FB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC4is2DSbvsTo', symObjAddr: 0x7D0, symBinAddr: 0x8510, symSize: 0x10 }
-  - { offsetInCU: 0x79E, offset: 0x7B51B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC4is2DSbvsTo', symObjAddr: 0x7D0, symBinAddr: 0x8510, symSize: 0x10 }
-  - { offsetInCU: 0x7D7, offset: 0x7B554, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7isMetalSbvgTo', symObjAddr: 0x7E0, symBinAddr: 0x8520, symSize: 0x10 }
-  - { offsetInCU: 0x7F7, offset: 0x7B574, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7isMetalSbvgTo', symObjAddr: 0x7E0, symBinAddr: 0x8520, symSize: 0x10 }
-  - { offsetInCU: 0x82D, offset: 0x7B5AA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7isMetalSbvsTo', symObjAddr: 0x7F0, symBinAddr: 0x8530, symSize: 0x10 }
-  - { offsetInCU: 0x84D, offset: 0x7B5CA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7isMetalSbvsTo', symObjAddr: 0x7F0, symBinAddr: 0x8530, symSize: 0x10 }
-  - { offsetInCU: 0x870, offset: 0x7B5ED, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18drawingBufferWidthSivgTo', symObjAddr: 0x800, symBinAddr: 0x8540, symSize: 0x34 }
-  - { offsetInCU: 0x8A2, offset: 0x7B61F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19drawingBufferHeightSivgTo', symObjAddr: 0x904, symBinAddr: 0x8644, symSize: 0x34 }
-  - { offsetInCU: 0x8EA, offset: 0x7B667, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5widthSfvgTo', symObjAddr: 0xA08, symBinAddr: 0x8748, symSize: 0x20 }
-  - { offsetInCU: 0x952, offset: 0x7B6CF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6heightSfvgTo', symObjAddr: 0xA4C, symBinAddr: 0x878C, symSize: 0x20 }
-  - { offsetInCU: 0x9F1, offset: 0x7B76E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11initContextyySS_S4bs5Int32VS5btFTo', symObjAddr: 0xAB4, symBinAddr: 0x87F4, symSize: 0xC4 }
-  - { offsetInCU: 0xAB4, offset: 0x7B831, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17initWebGPUContextyys5Int64VFTo', symObjAddr: 0xD10, symBinAddr: 0x8A50, symSize: 0x30 }
-  - { offsetInCU: 0xB64, offset: 0x7B8E1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC015initContextWithE10AttributesyySS_S4bs5Int32VS5btFTo', symObjAddr: 0x15B0, symBinAddr: 0x92F0, symSize: 0xC4 }
-  - { offsetInCU: 0xBCE, offset: 0x7B94B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15create2DContextys5Int64VSb_S3bs5Int32VS5bAHtFTo', symObjAddr: 0x18CC, symBinAddr: 0x960C, symSize: 0xB0 }
-  - { offsetInCU: 0xC0B, offset: 0x7B988, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11forceLayoutyy12CoreGraphics7CGFloatV_AGtFTo', symObjAddr: 0x1A3C, symBinAddr: 0x977C, symSize: 0xB8 }
-  - { offsetInCU: 0xC83, offset: 0x7BA00, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8snapshotySo7UIImageCSgSbFTo', symObjAddr: 0x1BD8, symBinAddr: 0x9918, symSize: 0x3C }
-  - { offsetInCU: 0xCB6, offset: 0x7BA33, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8rendererAA9NSCRenderCSgvgTo', symObjAddr: 0x1C14, symBinAddr: 0x9954, symSize: 0x10 }
-  - { offsetInCU: 0xCD6, offset: 0x7BA53, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8rendererAA9NSCRenderCSgvgTo', symObjAddr: 0x1C14, symBinAddr: 0x9954, symSize: 0x10 }
-  - { offsetInCU: 0xD10, offset: 0x7BA8D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8rendererAA9NSCRenderCSgvsTo', symObjAddr: 0x1C24, symBinAddr: 0x9964, symSize: 0x34 }
-  - { offsetInCU: 0xD6B, offset: 0x7BAE8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6renderSbyFTo', symObjAddr: 0x1CA0, symBinAddr: 0x99E0, symSize: 0x48 }
-  - { offsetInCU: 0xE05, offset: 0x7BB82, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13context2DTestyys5Int64VFTo', symObjAddr: 0x1D34, symBinAddr: 0x9A74, symSize: 0x64 }
-  - { offsetInCU: 0xECA, offset: 0x7BC47, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC22context2DTestToDataURLySSs5Int64VFTo', symObjAddr: 0x1DF0, symBinAddr: 0x9B30, symSize: 0x94 }
-  - { offsetInCU: 0xF57, offset: 0x7BCD4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC23enterBackgroundListeneryycSgvsTo', symObjAddr: 0x1EC4, symBinAddr: 0x9C04, symSize: 0x6C }
-  - { offsetInCU: 0xFB9, offset: 0x7BD36, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC20becomeActiveListeneryycSgvsTo', symObjAddr: 0x1FD4, symBinAddr: 0x9D14, symSize: 0x6C }
-  - { offsetInCU: 0x1016, offset: 0x7BD93, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvgTo', symObjAddr: 0x2040, symBinAddr: 0x9D80, symSize: 0xB0 }
-  - { offsetInCU: 0x1068, offset: 0x7BDE5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvsTo', symObjAddr: 0x21C0, symBinAddr: 0x9F00, symSize: 0x94 }
-  - { offsetInCU: 0x10FA, offset: 0x7BE77, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5coderACSgSo7NSCoderC_tcfcTo', symObjAddr: 0x2EAC, symBinAddr: 0xABEC, symSize: 0x28 }
-  - { offsetInCU: 0x114F, offset: 0x7BECC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5frameACSo6CGRectV_tcfcTo', symObjAddr: 0x392C, symBinAddr: 0xB66C, symSize: 0x20 }
-  - { offsetInCU: 0x1182, offset: 0x7BEFF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvgTo', symObjAddr: 0x394C, symBinAddr: 0xB68C, symSize: 0x10 }
-  - { offsetInCU: 0x11A2, offset: 0x7BF1F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvgTo', symObjAddr: 0x394C, symBinAddr: 0xB68C, symSize: 0x10 }
-  - { offsetInCU: 0x11DA, offset: 0x7BF57, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvsTo', symObjAddr: 0x395C, symBinAddr: 0xB69C, symSize: 0x34 }
-  - { offsetInCU: 0x1248, offset: 0x7BFC5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13readyListenerAA0cE0_pSgvgTo', symObjAddr: 0x3A10, symBinAddr: 0xB750, symSize: 0x20 }
-  - { offsetInCU: 0x12A2, offset: 0x7C01F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13readyListenerAA0cE0_pSgvsTo', symObjAddr: 0x3A30, symBinAddr: 0xB770, symSize: 0x34 }
-  - { offsetInCU: 0x1302, offset: 0x7C07F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11setListeneryyAA0cE0_pSgFTo', symObjAddr: 0x3A94, symBinAddr: 0xB7D4, symSize: 0x34 }
-  - { offsetInCU: 0x1446, offset: 0x7C1C3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC14layoutSubviewsyyFTo', symObjAddr: 0x3DE0, symBinAddr: 0xBB20, symSize: 0x28 }
-  - { offsetInCU: 0x1479, offset: 0x7C1F6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCfDTo', symObjAddr: 0x410C, symBinAddr: 0xBE4C, symSize: 0x24 }
-  - { offsetInCU: 0x14B4, offset: 0x7C231, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC21getBoundingClientRectyySo6UIViewC_SvtFZTo', symObjAddr: 0x41F8, symBinAddr: 0xBF38, symSize: 0x34 }
-  - { offsetInCU: 0x14E7, offset: 0x7C264, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC14shared_context33_508084857CA7D194CA72FEB80DD78002LLs5Int64VvgZTf4d_n', symObjAddr: 0x4B8C, symBinAddr: 0xC8CC, symSize: 0x298 }
-  - { offsetInCU: 0x1664, offset: 0x7C3E1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC21getBoundingClientRectyySo6UIViewC_SvtFZTf4nnd_n', symObjAddr: 0x4EE8, symBinAddr: 0xCC28, symSize: 0xA0 }
-  - { offsetInCU: 0x18E0, offset: 0x7C65D, size: 0x8, addend: 0x0, symName: '_$sIeg_IeyB_TR', symObjAddr: 0x1E98, symBinAddr: 0x9BD8, symSize: 0x2C }
-  - { offsetInCU: 0x18F8, offset: 0x7C675, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_So8NSStringCABIeyByy_TR', symObjAddr: 0x2148, symBinAddr: 0x9E88, symSize: 0x78 }
-  - { offsetInCU: 0x1910, offset: 0x7C68D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvpACTK', symObjAddr: 0x22B0, symBinAddr: 0x9FF0, symSize: 0x94 }
-  - { offsetInCU: 0x1948, offset: 0x7C6C5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvpACTk', symObjAddr: 0x2344, symBinAddr: 0xA084, symSize: 0xB8 }
-  - { offsetInCU: 0x198A, offset: 0x7C707, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCytIegnnr_SSABIeggg_TR', symObjAddr: 0x23FC, symBinAddr: 0xA13C, symSize: 0x6C }
-  - { offsetInCU: 0x1A3A, offset: 0x7C7B7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCfETo', symObjAddr: 0x4130, symBinAddr: 0xBE70, symSize: 0xC4 }
-  - { offsetInCU: 0x1A6A, offset: 0x7C7E7, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_SgWOy', symObjAddr: 0x422C, symBinAddr: 0xBF6C, symSize: 0x10 }
-  - { offsetInCU: 0x1A7E, offset: 0x7C7FB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCMa', symObjAddr: 0x423C, symBinAddr: 0xBF7C, symSize: 0x20 }
-  - { offsetInCU: 0x1A92, offset: 0x7C80F, size: 0x8, addend: 0x0, symName: '_$ss29getContiguousArrayStorageType3fors01_bcD0CyxGmxm_tlFSo18NSLayoutConstraintC_Tgm5', symObjAddr: 0x425C, symBinAddr: 0xBF9C, symSize: 0x64 }
-  - { offsetInCU: 0x1C99, offset: 0x7CA16, size: 0x8, addend: 0x0, symName: ___swift_instantiateConcreteTypeFromMangledName, symObjAddr: 0x4E24, symBinAddr: 0xCB64, symSize: 0x40 }
-  - { offsetInCU: 0x1CAD, offset: 0x7CA2A, size: 0x8, addend: 0x0, symName: '_$sypSgWOh', symObjAddr: 0x4E64, symBinAddr: 0xCBA4, symSize: 0x40 }
-  - { offsetInCU: 0x1CC1, offset: 0x7CA3E, size: 0x8, addend: 0x0, symName: ___swift_project_boxed_opaque_existential_0, symObjAddr: 0x4EA4, symBinAddr: 0xCBE4, symSize: 0x24 }
-  - { offsetInCU: 0x1CD5, offset: 0x7CA52, size: 0x8, addend: 0x0, symName: ___swift_destroy_boxed_opaque_existential_0, symObjAddr: 0x4EC8, symBinAddr: 0xCC08, symSize: 0x20 }
-  - { offsetInCU: 0x1CF4, offset: 0x7CA71, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSo19UIGestureRecognizerCIeyByy_SSADIeggg_TRTA', symObjAddr: 0x53B4, symBinAddr: 0xD0F4, symSize: 0x48 }
-  - { offsetInCU: 0x1D1D, offset: 0x7CA9A, size: 0x8, addend: 0x0, symName: _block_copy_helper, symObjAddr: 0x53FC, symBinAddr: 0xD13C, symSize: 0x10 }
-  - { offsetInCU: 0x1D31, offset: 0x7CAAE, size: 0x8, addend: 0x0, symName: _block_destroy_helper, symObjAddr: 0x540C, symBinAddr: 0xD14C, symSize: 0x8 }
-  - { offsetInCU: 0x1D45, offset: 0x7CAC2, size: 0x8, addend: 0x0, symName: '_$sIeg_SgWOe', symObjAddr: 0x5414, symBinAddr: 0xD154, symSize: 0x10 }
-  - { offsetInCU: 0x1D64, offset: 0x7CAE1, size: 0x8, addend: 0x0, symName: '_$sIeyB_Ieg_TRTA', symObjAddr: 0x5424, symBinAddr: 0xD164, symSize: 0xC }
-  - { offsetInCU: 0x1D8D, offset: 0x7CB0A, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCytIegnnr_SSABIeggg_TRTA', symObjAddr: 0x5454, symBinAddr: 0xD194, symSize: 0x8 }
-  - { offsetInCU: 0x1DAC, offset: 0x7CB29, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_SSABytIegnnr_TRTA', symObjAddr: 0x545C, symBinAddr: 0xD19C, symSize: 0x30 }
-  - { offsetInCU: 0x1DD5, offset: 0x7CB52, size: 0x8, addend: 0x0, symName: '_$sypWOb', symObjAddr: 0x548C, symBinAddr: 0xD1CC, symSize: 0x10 }
-  - { offsetInCU: 0x1DE9, offset: 0x7CB66, size: 0x8, addend: 0x0, symName: '_$sypWOc', symObjAddr: 0x54D4, symBinAddr: 0xD214, symSize: 0x3C }
-  - { offsetInCU: 0x206E, offset: 0x7CDEB, size: 0x8, addend: 0x0, symName: '_$sSD17dictionaryLiteralSDyxq_Gx_q_td_tcfCSS_ypTgm5Tf4g_n', symObjAddr: 0x4A7C, symBinAddr: 0xC7BC, symSize: 0x110 }
-  - { offsetInCU: 0x251C, offset: 0x7D299, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvg', symObjAddr: 0x2E0, symBinAddr: 0x8020, symSize: 0x44 }
-  - { offsetInCU: 0x254F, offset: 0x7D2CC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvs', symObjAddr: 0x354, symBinAddr: 0x8094, symSize: 0xEC }
-  - { offsetInCU: 0x259B, offset: 0x7D318, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvM', symObjAddr: 0x440, symBinAddr: 0x8180, symSize: 0x58 }
-  - { offsetInCU: 0x25C0, offset: 0x7D33D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvM.resume.0', symObjAddr: 0x498, symBinAddr: 0x81D8, symSize: 0xE0 }
-  - { offsetInCU: 0x2601, offset: 0x7D37E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8nativeGLs5Int64Vvg', symObjAddr: 0x5BC, symBinAddr: 0x82FC, symSize: 0x44 }
-  - { offsetInCU: 0x2659, offset: 0x7D3D6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13nativeContexts5Int64Vvg', symObjAddr: 0x68C, symBinAddr: 0x83CC, symSize: 0x44 }
-  - { offsetInCU: 0x27C7, offset: 0x7D544, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18drawingBufferWidthSivg', symObjAddr: 0x834, symBinAddr: 0x8574, symSize: 0xD0 }
-  - { offsetInCU: 0x28EC, offset: 0x7D669, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19drawingBufferHeightSivg', symObjAddr: 0x938, symBinAddr: 0x8678, symSize: 0xD0 }
-  - { offsetInCU: 0x2A32, offset: 0x7D7AF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5widthSfvg', symObjAddr: 0xA28, symBinAddr: 0x8768, symSize: 0x24 }
-  - { offsetInCU: 0x2A7A, offset: 0x7D7F7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6heightSfvg', symObjAddr: 0xA6C, symBinAddr: 0x87AC, symSize: 0x24 }
-  - { offsetInCU: 0x2AAE, offset: 0x7D82B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11initContextyySS_S4bs5Int32VS5btF', symObjAddr: 0xA90, symBinAddr: 0x87D0, symSize: 0x24 }
-  - { offsetInCU: 0x2C3C, offset: 0x7D9B9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17initWebGPUContextyys5Int64VF', symObjAddr: 0xB78, symBinAddr: 0x88B8, symSize: 0x198 }
-  - { offsetInCU: 0x302F, offset: 0x7DDAC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC015initContextWithE10AttributesyySS_S4bs5Int32VS5btF', symObjAddr: 0xD40, symBinAddr: 0x8A80, symSize: 0x870 }
-  - { offsetInCU: 0x3832, offset: 0x7E5AF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15create2DContextys5Int64VSb_S3bs5Int32VS5bAHtF', symObjAddr: 0x1674, symBinAddr: 0x93B4, symSize: 0x258 }
-  - { offsetInCU: 0x3C64, offset: 0x7E9E1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11forceLayoutyy12CoreGraphics7CGFloatV_AGtF', symObjAddr: 0x197C, symBinAddr: 0x96BC, symSize: 0xC0 }
-  - { offsetInCU: 0x3CF5, offset: 0x7EA72, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8snapshotySo7UIImageCSgSbF', symObjAddr: 0x1AF4, symBinAddr: 0x9834, symSize: 0xE4 }
-  - { offsetInCU: 0x3E50, offset: 0x7EBCD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6renderSbyF', symObjAddr: 0x1C58, symBinAddr: 0x9998, symSize: 0x48 }
-  - { offsetInCU: 0x3ED6, offset: 0x7EC53, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13context2DTestyys5Int64VF', symObjAddr: 0x1CE8, symBinAddr: 0x9A28, symSize: 0x4C }
-  - { offsetInCU: 0x3FF7, offset: 0x7ED74, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC22context2DTestToDataURLySSs5Int64VF', symObjAddr: 0x1D98, symBinAddr: 0x9AD8, symSize: 0x58 }
-  - { offsetInCU: 0x40ED, offset: 0x7EE6A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvg', symObjAddr: 0x20F0, symBinAddr: 0x9E30, symSize: 0x58 }
-  - { offsetInCU: 0x4139, offset: 0x7EEB6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvs', symObjAddr: 0x2254, symBinAddr: 0x9F94, symSize: 0x5C }
-  - { offsetInCU: 0x4162, offset: 0x7EEDF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvM', symObjAddr: 0x2468, symBinAddr: 0xA1A8, symSize: 0x44 }
-  - { offsetInCU: 0x4188, offset: 0x7EF05, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvM.resume.0', symObjAddr: 0x24AC, symBinAddr: 0xA1EC, symSize: 0x4 }
-  - { offsetInCU: 0x424A, offset: 0x7EFC7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5coderACSgSo7NSCoderC_tcfc', symObjAddr: 0x24B0, symBinAddr: 0xA1F0, symSize: 0x9FC }
-  - { offsetInCU: 0x446D, offset: 0x7F1EA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5frameACSo6CGRectV_tcfC', symObjAddr: 0x2ED4, symBinAddr: 0xAC14, symSize: 0x50 }
-  - { offsetInCU: 0x4496, offset: 0x7F213, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5frameACSo6CGRectV_tcfc', symObjAddr: 0x2F24, symBinAddr: 0xAC64, symSize: 0xA08 }
-  - { offsetInCU: 0x46DA, offset: 0x7F457, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvW', symObjAddr: 0x3990, symBinAddr: 0xB6D0, symSize: 0x80 }
-  - { offsetInCU: 0x47D0, offset: 0x7F54D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11setListeneryyAA0cE0_pSgF', symObjAddr: 0x3A64, symBinAddr: 0xB7A4, symSize: 0x30 }
-  - { offsetInCU: 0x486E, offset: 0x7F5EB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6resize33_508084857CA7D194CA72FEB80DD78002LLyyF', symObjAddr: 0x3AC8, symBinAddr: 0xB808, symSize: 0x144 }
-  - { offsetInCU: 0x4A6F, offset: 0x7F7EC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC14layoutSubviewsyyF', symObjAddr: 0x3C0C, symBinAddr: 0xB94C, symSize: 0x1D4 }
-  - { offsetInCU: 0x4CEC, offset: 0x7FA69, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCfD', symObjAddr: 0x3E08, symBinAddr: 0xBB48, symSize: 0x304 }
-  - { offsetInCU: 0x4D7C, offset: 0x7FAF9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC21getBoundingClientRectyySo6UIViewC_SvtFZ', symObjAddr: 0x41F4, symBinAddr: 0xBF34, symSize: 0x4 }
-  - { offsetInCU: 0x4DA4, offset: 0x7FB21, size: 0x8, addend: 0x0, symName: '_$ss22__RawDictionaryStorageC4findys10_HashTableV6BucketV6bucket_Sb5foundtxSHRzlFSS_Tg5', symObjAddr: 0x42C0, symBinAddr: 0xC000, symSize: 0x64 }
-  - { offsetInCU: 0x4DFE, offset: 0x7FB7B, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV7_insert2at3key5valueys10_HashTableV6BucketV_xnq_ntFSS_ypTg5', symObjAddr: 0x4324, symBinAddr: 0xC064, symSize: 0x6C }
-  - { offsetInCU: 0x4E7E, offset: 0x7FBFB, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV12mutatingFind_8isUniques10_HashTableV6BucketV6bucket_Sb5foundtx_SbtFSS_ypTg5', symObjAddr: 0x4390, symBinAddr: 0xC0D0, symSize: 0xD8 }
-  - { offsetInCU: 0x4EBB, offset: 0x7FC38, size: 0x8, addend: 0x0, symName: '_$ss22__RawDictionaryStorageC4find_9hashValues10_HashTableV6BucketV6bucket_Sb5foundtx_SitSHRzlFSS_Tg5', symObjAddr: 0x4468, symBinAddr: 0xC1A8, symSize: 0xE0 }
-  - { offsetInCU: 0x4F36, offset: 0x7FCB3, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV4copyyyFSS_ypTg5', symObjAddr: 0x4548, symBinAddr: 0xC288, symSize: 0x1F4 }
-  - { offsetInCU: 0x4FF2, offset: 0x7FD6F, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV20_copyOrMoveAndResize8capacity12moveElementsySi_SbtFSS_ypTg5', symObjAddr: 0x473C, symBinAddr: 0xC47C, symSize: 0x340 }
-  - { offsetInCU: 0x27, offset: 0x7FFD7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative7GLUtilsCfD', symObjAddr: 0x0, symBinAddr: 0xD2B4, symSize: 0x10 }
-  - { offsetInCU: 0x62, offset: 0x80012, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative7GLUtilsCMa', symObjAddr: 0x10, symBinAddr: 0xD2C4, symSize: 0x20 }
-  - { offsetInCU: 0x1AF, offset: 0x8015F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative7GLUtilsCfD', symObjAddr: 0x0, symBinAddr: 0xD2B4, symSize: 0x10 }
-  - { offsetInCU: 0x65, offset: 0x801EE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8mPrograms6UInt32VvgTo', symObjAddr: 0x0, symBinAddr: 0xD2E4, symSize: 0x10 }
-  - { offsetInCU: 0x85, offset: 0x8020E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8mPrograms6UInt32VvgTo', symObjAddr: 0x0, symBinAddr: 0xD2E4, symSize: 0x10 }
-  - { offsetInCU: 0xBB, offset: 0x80244, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8mPrograms6UInt32VvsTo', symObjAddr: 0x10, symBinAddr: 0xD2F4, symSize: 0x10 }
-  - { offsetInCU: 0xDB, offset: 0x80264, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8mPrograms6UInt32VvsTo', symObjAddr: 0x10, symBinAddr: 0xD2F4, symSize: 0x10 }
-  - { offsetInCU: 0x114, offset: 0x8029D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3rbos6UInt32VvgTo', symObjAddr: 0x20, symBinAddr: 0xD304, symSize: 0x44 }
-  - { offsetInCU: 0x16C, offset: 0x802F5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3rbos6UInt32VvsTo', symObjAddr: 0x64, symBinAddr: 0xD348, symSize: 0x48 }
-  - { offsetInCU: 0x1C7, offset: 0x80350, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3fbos6UInt32VvgTo', symObjAddr: 0xAC, symBinAddr: 0xD390, symSize: 0x44 }
-  - { offsetInCU: 0x21F, offset: 0x803A8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3fbos6UInt32VvsTo', symObjAddr: 0xF0, symBinAddr: 0xD3D4, symSize: 0x48 }
-  - { offsetInCU: 0x27A, offset: 0x80403, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC5widthSivgTo', symObjAddr: 0x138, symBinAddr: 0xD41C, symSize: 0x10 }
-  - { offsetInCU: 0x29A, offset: 0x80423, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC5widthSivgTo', symObjAddr: 0x138, symBinAddr: 0xD41C, symSize: 0x10 }
-  - { offsetInCU: 0x2D0, offset: 0x80459, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC5widthSivsTo', symObjAddr: 0x148, symBinAddr: 0xD42C, symSize: 0x10 }
-  - { offsetInCU: 0x2F0, offset: 0x80479, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC5widthSivsTo', symObjAddr: 0x148, symBinAddr: 0xD42C, symSize: 0x10 }
-  - { offsetInCU: 0x329, offset: 0x804B2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC6heightSivgTo', symObjAddr: 0x158, symBinAddr: 0xD43C, symSize: 0x10 }
-  - { offsetInCU: 0x349, offset: 0x804D2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC6heightSivgTo', symObjAddr: 0x158, symBinAddr: 0xD43C, symSize: 0x10 }
-  - { offsetInCU: 0x37F, offset: 0x80508, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC6heightSivsTo', symObjAddr: 0x168, symBinAddr: 0xD44C, symSize: 0x10 }
-  - { offsetInCU: 0x39F, offset: 0x80528, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC6heightSivsTo', symObjAddr: 0x168, symBinAddr: 0xD44C, symSize: 0x10 }
-  - { offsetInCU: 0x3D8, offset: 0x80561, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC2abs6UInt32VvgTo', symObjAddr: 0x178, symBinAddr: 0xD45C, symSize: 0x44 }
-  - { offsetInCU: 0x430, offset: 0x805B9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC2abs6UInt32VvsTo', symObjAddr: 0x1BC, symBinAddr: 0xD4A0, symSize: 0x48 }
-  - { offsetInCU: 0x48B, offset: 0x80614, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3poss5Int32VvgTo', symObjAddr: 0x204, symBinAddr: 0xD4E8, symSize: 0x10 }
-  - { offsetInCU: 0x4AB, offset: 0x80634, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3poss5Int32VvgTo', symObjAddr: 0x204, symBinAddr: 0xD4E8, symSize: 0x10 }
-  - { offsetInCU: 0x4E1, offset: 0x8066A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3poss5Int32VvsTo', symObjAddr: 0x214, symBinAddr: 0xD4F8, symSize: 0x10 }
-  - { offsetInCU: 0x501, offset: 0x8068A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3poss5Int32VvsTo', symObjAddr: 0x214, symBinAddr: 0xD4F8, symSize: 0x10 }
-  - { offsetInCU: 0x53A, offset: 0x806C3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10samplerPoss5Int32VvgTo', symObjAddr: 0x224, symBinAddr: 0xD508, symSize: 0x10 }
-  - { offsetInCU: 0x55A, offset: 0x806E3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10samplerPoss5Int32VvgTo', symObjAddr: 0x224, symBinAddr: 0xD508, symSize: 0x10 }
-  - { offsetInCU: 0x590, offset: 0x80719, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10samplerPoss5Int32VvsTo', symObjAddr: 0x234, symBinAddr: 0xD518, symSize: 0x10 }
-  - { offsetInCU: 0x5B0, offset: 0x80739, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10samplerPoss5Int32VvsTo', symObjAddr: 0x234, symBinAddr: 0xD518, symSize: 0x10 }
-  - { offsetInCU: 0x5E9, offset: 0x80772, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9vextexBufSaySfGvgTo', symObjAddr: 0x244, symBinAddr: 0xD528, symSize: 0x48 }
-  - { offsetInCU: 0x63F, offset: 0x807C8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9vextexBufSaySfGvsTo', symObjAddr: 0x28C, symBinAddr: 0xD570, symSize: 0x40 }
-  - { offsetInCU: 0x682, offset: 0x8080B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13SIZE_OF_FLOATSivgZTo', symObjAddr: 0x2CC, symBinAddr: 0xD5B0, symSize: 0x8 }
-  - { offsetInCU: 0x69E, offset: 0x80827, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13VERTEX_SHADERSSvgZTo', symObjAddr: 0x2D4, symBinAddr: 0xD5B8, symSize: 0x2C }
-  - { offsetInCU: 0x6D0, offset: 0x80859, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7surfaceSo9IOSurfaceCSgvgTo', symObjAddr: 0x300, symBinAddr: 0xD5E4, symSize: 0x10 }
-  - { offsetInCU: 0x6F0, offset: 0x80879, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7surfaceSo9IOSurfaceCSgvgTo', symObjAddr: 0x300, symBinAddr: 0xD5E4, symSize: 0x10 }
-  - { offsetInCU: 0x728, offset: 0x808B1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7surfaceSo9IOSurfaceCSgvsTo', symObjAddr: 0x310, symBinAddr: 0xD5F4, symSize: 0x34 }
-  - { offsetInCU: 0x781, offset: 0x8090A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8pixelBufs9UnmanagedVySo11CVBufferRefaGSgvgTo', symObjAddr: 0x418, symBinAddr: 0xD6FC, symSize: 0x10 }
-  - { offsetInCU: 0x7A1, offset: 0x8092A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8pixelBufs9UnmanagedVySo11CVBufferRefaGSgvgTo', symObjAddr: 0x418, symBinAddr: 0xD6FC, symSize: 0x10 }
-  - { offsetInCU: 0x7D7, offset: 0x80960, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8pixelBufs9UnmanagedVySo11CVBufferRefaGSgvsTo', symObjAddr: 0x428, symBinAddr: 0xD70C, symSize: 0x10 }
-  - { offsetInCU: 0x7F7, offset: 0x80980, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8pixelBufs9UnmanagedVySo11CVBufferRefaGSgvsTo', symObjAddr: 0x428, symBinAddr: 0xD70C, symSize: 0x10 }
-  - { offsetInCU: 0x846, offset: 0x809CF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCACycfcTo', symObjAddr: 0x5A4, symBinAddr: 0xD848, symSize: 0x20 }
-  - { offsetInCU: 0x878, offset: 0x80A01, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7destroyyyFTo', symObjAddr: 0x708, symBinAddr: 0xD9AC, symSize: 0x28 }
-  - { offsetInCU: 0x8D0, offset: 0x80A59, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10texImage2Dyys5Int32V_A4fA9NSCCanvasCAHSbtFTo', symObjAddr: 0x744, symBinAddr: 0xD9E8, symSize: 0x88 }
-  - { offsetInCU: 0x934, offset: 0x80ABD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9drawFrame6buffer5width6height14internalFormat6format10flipYWebGLySo11CVBufferRefa_S2is5Int32VANSbtFTo', symObjAddr: 0x7CC, symBinAddr: 0xDA70, symSize: 0x7C }
-  - { offsetInCU: 0x9D6, offset: 0x80B5F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13createSurfaceyyFTo', symObjAddr: 0xBF4, symBinAddr: 0xDE98, symSize: 0x28 }
-  - { offsetInCU: 0xAC0, offset: 0x80C49, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCMa', symObjAddr: 0x584, symBinAddr: 0xD828, symSize: 0x20 }
-  - { offsetInCU: 0xB34, offset: 0x80CBD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCfETo', symObjAddr: 0xC4C, symBinAddr: 0xDEF0, symSize: 0x58 }
-  - { offsetInCU: 0x123B, offset: 0x813C4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCACycfC', symObjAddr: 0x438, symBinAddr: 0xD71C, symSize: 0x20 }
-  - { offsetInCU: 0x1255, offset: 0x813DE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCACycfc', symObjAddr: 0x458, symBinAddr: 0xD73C, symSize: 0xEC }
-  - { offsetInCU: 0x128D, offset: 0x81416, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7destroyyyF', symObjAddr: 0x5C4, symBinAddr: 0xD868, symSize: 0x144 }
-  - { offsetInCU: 0x1448, offset: 0x815D1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10texImage2Dyys5Int32V_A4fA9NSCCanvasCAHSbtF', symObjAddr: 0x730, symBinAddr: 0xD9D4, symSize: 0x14 }
-  - { offsetInCU: 0x14F9, offset: 0x81682, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13createSurfaceyyF', symObjAddr: 0x848, symBinAddr: 0xDAEC, symSize: 0x3AC }
-  - { offsetInCU: 0x1869, offset: 0x819F2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCfD', symObjAddr: 0xC1C, symBinAddr: 0xDEC0, symSize: 0x30 }
-  - { offsetInCU: 0x1954, offset: 0x81ADD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10texImage2Dyys5Int32V_A4fA9NSCCanvasCAHSbtFTf4ddnndnndn_n', symObjAddr: 0xCA4, symBinAddr: 0xDF48, symSize: 0x65C }
-  - { offsetInCU: 0x2152, offset: 0x822DB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9drawFrame6buffer5width6height14internalFormat6format10flipYWebGLySo11CVBufferRefa_S2is5Int32VANSbtFTf4nnnnndn_n', symObjAddr: 0x1344, symBinAddr: 0xE5E8, symSize: 0x6C8 }
-  - { offsetInCU: 0x10C, offset: 0x82C9B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC6target6actionAEypSg_10ObjectiveC8SelectorVSgtcfcTo', symObjAddr: 0xED4, symBinAddr: 0xFB5C, symSize: 0x68 }
-  - { offsetInCU: 0x19C, offset: 0x82D2B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerCfETo', symObjAddr: 0xF48, symBinAddr: 0xFBD0, symSize: 0x10 }
-  - { offsetInCU: 0x1CB, offset: 0x82D5A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC6handleyySo19UIGestureRecognizerCFTo', symObjAddr: 0xF58, symBinAddr: 0xFBE0, symSize: 0x4 }
-  - { offsetInCU: 0x368, offset: 0x82EF7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerCACycfcTo', symObjAddr: 0x16DC, symBinAddr: 0x10364, symSize: 0x2C }
-  - { offsetInCU: 0x5D4, offset: 0x83163, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerCfETo', symObjAddr: 0x1744, symBinAddr: 0x103CC, symSize: 0x68 }
-  - { offsetInCU: 0x603, offset: 0x83192, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerCMa', symObjAddr: 0x17AC, symBinAddr: 0x10434, symSize: 0x20 }
-  - { offsetInCU: 0x617, offset: 0x831A6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerCMa', symObjAddr: 0x17CC, symBinAddr: 0x10454, symSize: 0x20 }
-  - { offsetInCU: 0x62B, offset: 0x831BA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwCP', symObjAddr: 0x17EC, symBinAddr: 0x10474, symSize: 0x30 }
-  - { offsetInCU: 0x63F, offset: 0x831CE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwxx', symObjAddr: 0x181C, symBinAddr: 0x104A4, symSize: 0x8 }
-  - { offsetInCU: 0x653, offset: 0x831E2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwcp', symObjAddr: 0x1824, symBinAddr: 0x104AC, symSize: 0x3C }
-  - { offsetInCU: 0x667, offset: 0x831F6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwca', symObjAddr: 0x1860, symBinAddr: 0x104E8, symSize: 0x50 }
-  - { offsetInCU: 0x67B, offset: 0x8320A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwta', symObjAddr: 0x18BC, symBinAddr: 0x10538, symSize: 0x40 }
-  - { offsetInCU: 0x68F, offset: 0x8321E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwet', symObjAddr: 0x18FC, symBinAddr: 0x10578, symSize: 0x48 }
-  - { offsetInCU: 0x6A3, offset: 0x83232, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwst', symObjAddr: 0x1944, symBinAddr: 0x105C0, symSize: 0x40 }
-  - { offsetInCU: 0x6B7, offset: 0x83246, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVMa', symObjAddr: 0x1984, symBinAddr: 0x10600, symSize: 0x10 }
-  - { offsetInCU: 0x6CB, offset: 0x8325A, size: 0x8, addend: 0x0, symName: '_$sypSgWOc', symObjAddr: 0x1994, symBinAddr: 0x10610, symSize: 0x48 }
-  - { offsetInCU: 0x6DF, offset: 0x8326E, size: 0x8, addend: 0x0, symName: '_$sSo7UITouchCSo8NSObjectCSH10ObjectiveCWl', symObjAddr: 0x1AA0, symBinAddr: 0x10658, symSize: 0x58 }
-  - { offsetInCU: 0x6F3, offset: 0x83282, size: 0x8, addend: 0x0, symName: '_$sSh8IteratorV8_VariantOyx__GSHRzlWOe', symObjAddr: 0x1AF8, symBinAddr: 0x106B0, symSize: 0x8 }
-  - { offsetInCU: 0x761, offset: 0x832F0, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_SgWOe', symObjAddr: 0x1DE4, symBinAddr: 0x1099C, symSize: 0x10 }
-  - { offsetInCU: 0xCBB, offset: 0x8384A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC12touchesBegan_4withyShySo7UITouchCG_So7UIEventCtF', symObjAddr: 0x0, symBinAddr: 0xECB0, symSize: 0x540 }
-  - { offsetInCU: 0xF57, offset: 0x83AE6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC12touchesMoved_4withyShySo7UITouchCG_So7UIEventCtF', symObjAddr: 0x54C, symBinAddr: 0xF1FC, symSize: 0xE0 }
-  - { offsetInCU: 0xFD6, offset: 0x83B65, size: 0x8, addend: 0x0, symName: '_$sSa6remove2atxSi_tF12CanvasNative15NSCTouchHandlerC7PointerV_Tg5', symObjAddr: 0x6F0, symBinAddr: 0xF38C, symSize: 0x9C }
-  - { offsetInCU: 0x1069, offset: 0x83BF8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC6target6actionAEypSg_10ObjectiveC8SelectorVSgtcfc', symObjAddr: 0xDCC, symBinAddr: 0xFA54, symSize: 0x108 }
-  - { offsetInCU: 0x11B3, offset: 0x83D42, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC6onMove33_044DDF836BDB3B89B481C6F58BB6EF6BLLyySo19UIGestureRecognizerC_ShySo7UITouchCGSgtF', symObjAddr: 0x12D0, symBinAddr: 0xFF58, symSize: 0x40C }
-  - { offsetInCU: 0x18C9, offset: 0x84458, size: 0x8, addend: 0x0, symName: '_$ss12_ArrayBufferV20_consumeAndCreateNewAByxGyF12CanvasNative15NSCTouchHandlerC7PointerV_Tg5', symObjAddr: 0x1B00, symBinAddr: 0x106B8, symSize: 0x14 }
-  - { offsetInCU: 0x1968, offset: 0x844F7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC6canvasAcA9NSCCanvasC_tcfcTf4gn_n', symObjAddr: 0x1B14, symBinAddr: 0x106CC, symSize: 0x1DC }
-  - { offsetInCU: 0x27, offset: 0x846D4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC14FAILED_TO_LOADSSvgZTo', symObjAddr: 0x0, symBinAddr: 0x109AC, symSize: 0x2C }
-  - { offsetInCU: 0x4B, offset: 0x846F8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queueSo012OS_dispatch_E0CvpZ', symObjAddr: 0x2D8, symBinAddr: 0x10C4068, symSize: 0x0 }
-  - { offsetInCU: 0x65, offset: 0x84712, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC14FAILED_TO_LOADSSvgZTo', symObjAddr: 0x0, symBinAddr: 0x109AC, symSize: 0x2C }
-  - { offsetInCU: 0x98, offset: 0x84745, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queueSo012OS_dispatch_E0CvgZTo', symObjAddr: 0x178, symBinAddr: 0x10B24, symSize: 0x40 }
-  - { offsetInCU: 0x104, offset: 0x847B1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCACycfcTo', symObjAddr: 0x228, symBinAddr: 0x10BD4, symSize: 0x3C }
-  - { offsetInCU: 0x156, offset: 0x84803, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queue_WZ', symObjAddr: 0x2C, symBinAddr: 0x109D8, symSize: 0x10C }
-  - { offsetInCU: 0x181, offset: 0x8482E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCMa', symObjAddr: 0x208, symBinAddr: 0x10BB4, symSize: 0x20 }
-  - { offsetInCU: 0x195, offset: 0x84842, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCfETo', symObjAddr: 0x294, symBinAddr: 0x10C40, symSize: 0x4 }
-  - { offsetInCU: 0x1C0, offset: 0x8486D, size: 0x8, addend: 0x0, symName: '_$sSo17OS_dispatch_queueCMa', symObjAddr: 0x298, symBinAddr: 0x10C44, symSize: 0x3C }
-  - { offsetInCU: 0x348, offset: 0x849F5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queueSo012OS_dispatch_E0CvgZ', symObjAddr: 0x138, symBinAddr: 0x10AE4, symSize: 0x40 }
-  - { offsetInCU: 0x388, offset: 0x84A35, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCACycfC', symObjAddr: 0x1B8, symBinAddr: 0x10B64, symSize: 0x20 }
-  - { offsetInCU: 0x39C, offset: 0x84A49, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCACycfc', symObjAddr: 0x1D8, symBinAddr: 0x10B84, symSize: 0x30 }
-  - { offsetInCU: 0x3D8, offset: 0x84A85, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCfD', symObjAddr: 0x264, symBinAddr: 0x10C10, symSize: 0x30 }
-  - { offsetInCU: 0x2B, offset: 0x84AD3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC18createTextureCacheSo017CVOpenGLESTextureF3RefaSgyFZ', symObjAddr: 0x0, symBinAddr: 0x10C80, symSize: 0xA4 }
-  - { offsetInCU: 0x66, offset: 0x84B0E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC18createTextureCacheSo017CVOpenGLESTextureF3RefaSgyFZTo', symObjAddr: 0xA4, symBinAddr: 0x10D24, symSize: 0xA4 }
-  - { offsetInCU: 0xF9, offset: 0x84BA1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11createImageySo11CVBufferRefaSgSo022CVOpenGLESTextureCacheG0a_AFSo012CFDictionaryG0aSgs6UInt32Vs5Int32VA2p2NSitFZTo', symObjAddr: 0x1D8, symBinAddr: 0x10E58, symSize: 0x110 }
-  - { offsetInCU: 0x1A2, offset: 0x84C4A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11setupRenderAA9NSCRenderCyFZTo', symObjAddr: 0x30C, symBinAddr: 0x10F8C, symSize: 0x28 }
-  - { offsetInCU: 0x222, offset: 0x84CCA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC9drawFrameyySo8AVPlayerC_So0F15ItemVideoOutputCSo6CGSizeVAA9NSCRenderCs5Int32VANSbtFZTo', symObjAddr: 0x338, symBinAddr: 0x10FB8, symSize: 0xA0 }
-  - { offsetInCU: 0x29B, offset: 0x84D43, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11writeToFileyySo6NSDataC_SStKFZTo', symObjAddr: 0x4D0, symBinAddr: 0x11150, symSize: 0x15C }
-  - { offsetInCU: 0x330, offset: 0x84DD8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCACycfcTo', symObjAddr: 0x67C, symBinAddr: 0x112FC, symSize: 0x3C }
-  - { offsetInCU: 0x381, offset: 0x84E29, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC9drawFrameyySo8AVPlayerC_So0F15ItemVideoOutputCSo6CGSizeVAA9NSCRenderCs5Int32VANSbtFZTf4nnnnnndd_n', symObjAddr: 0x6E8, symBinAddr: 0x11368, symSize: 0x160 }
-  - { offsetInCU: 0x4DF, offset: 0x84F87, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC7getFile33_F00B23A4165DD6ABFCD23C8811C7DF43LLyS2SKFZTf4nd_g', symObjAddr: 0x848, symBinAddr: 0x114C8, symSize: 0x2E4 }
-  - { offsetInCU: 0x5AE, offset: 0x85056, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCMa', symObjAddr: 0xB2C, symBinAddr: 0x117AC, symSize: 0x20 }
-  - { offsetInCU: 0x5C2, offset: 0x8506A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOAEs5ErrorAAWl', symObjAddr: 0xB4C, symBinAddr: 0x117CC, symSize: 0x44 }
-  - { offsetInCU: 0x5D6, offset: 0x8507E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwCP', symObjAddr: 0xB90, symBinAddr: 0x11810, symSize: 0x2C }
-  - { offsetInCU: 0x5EA, offset: 0x85092, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwxx', symObjAddr: 0xBBC, symBinAddr: 0x1183C, symSize: 0x8 }
-  - { offsetInCU: 0x5FE, offset: 0x850A6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwca', symObjAddr: 0xBC4, symBinAddr: 0x11844, symSize: 0x40 }
-  - { offsetInCU: 0x612, offset: 0x850BA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwta', symObjAddr: 0xC10, symBinAddr: 0x11884, symSize: 0x30 }
-  - { offsetInCU: 0x626, offset: 0x850CE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwet', symObjAddr: 0xC40, symBinAddr: 0x118B4, symSize: 0x48 }
-  - { offsetInCU: 0x63A, offset: 0x850E2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwst', symObjAddr: 0xC88, symBinAddr: 0x118FC, symSize: 0x3C }
-  - { offsetInCU: 0x64E, offset: 0x850F6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwug', symObjAddr: 0xCC4, symBinAddr: 0x11938, symSize: 0x8 }
-  - { offsetInCU: 0x662, offset: 0x8510A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwup', symObjAddr: 0xCCC, symBinAddr: 0x11940, symSize: 0x4 }
-  - { offsetInCU: 0x676, offset: 0x8511E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwui', symObjAddr: 0xCD0, symBinAddr: 0x11944, symSize: 0x4 }
-  - { offsetInCU: 0x68A, offset: 0x85132, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOMa', symObjAddr: 0xCD4, symBinAddr: 0x11948, symSize: 0x10 }
-  - { offsetInCU: 0x712, offset: 0x851BA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP7_domainSSvgTW', symObjAddr: 0x3D8, symBinAddr: 0x11058, symSize: 0x4 }
-  - { offsetInCU: 0x72E, offset: 0x851D6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP5_codeSivgTW', symObjAddr: 0x3DC, symBinAddr: 0x1105C, symSize: 0x4 }
-  - { offsetInCU: 0x74A, offset: 0x851F2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP9_userInfoyXlSgvgTW', symObjAddr: 0x3E0, symBinAddr: 0x11060, symSize: 0x4 }
-  - { offsetInCU: 0x766, offset: 0x8520E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP19_getEmbeddedNSErroryXlSgyFTW', symObjAddr: 0x3E4, symBinAddr: 0x11064, symSize: 0x4 }
-  - { offsetInCU: 0xA14, offset: 0x854BC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC18createTextureCacheSo017CVOpenGLESTextureF3RefaSgyFZ', symObjAddr: 0x0, symBinAddr: 0x10C80, symSize: 0xA4 }
-  - { offsetInCU: 0xAAA, offset: 0x85552, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11createImageySo11CVBufferRefaSgSo022CVOpenGLESTextureCacheG0a_AFSo012CFDictionaryG0aSgs6UInt32Vs5Int32VA2p2NSitFZ', symObjAddr: 0x148, symBinAddr: 0x10DC8, symSize: 0x90 }
-  - { offsetInCU: 0xC31, offset: 0x856D9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11setupRenderAA9NSCRenderCyFZ', symObjAddr: 0x2E8, symBinAddr: 0x10F68, symSize: 0x24 }
-  - { offsetInCU: 0xC7B, offset: 0x85723, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC9drawFrameyySo8AVPlayerC_So0F15ItemVideoOutputCSo6CGSizeVAA9NSCRenderCs5Int32VANSbtFZ', symObjAddr: 0x334, symBinAddr: 0x10FB4, symSize: 0x4 }
-  - { offsetInCU: 0xC9D, offset: 0x85745, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11writeToFileyySo6NSDataC_SStKFZ', symObjAddr: 0x3E8, symBinAddr: 0x11068, symSize: 0xE8 }
-  - { offsetInCU: 0xD4D, offset: 0x857F5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCACycfC', symObjAddr: 0x62C, symBinAddr: 0x112AC, symSize: 0x20 }
-  - { offsetInCU: 0xD61, offset: 0x85809, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCACycfc', symObjAddr: 0x64C, symBinAddr: 0x112CC, symSize: 0x30 }
-  - { offsetInCU: 0xD97, offset: 0x8583F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCfD', symObjAddr: 0x6B8, symBinAddr: 0x11338, symSize: 0x30 }
-  - { offsetInCU: 0x27, offset: 0x85958, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x0, symBinAddr: 0x1195C, symSize: 0x4 }
-  - { offsetInCU: 0x71, offset: 0x859A2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZTo', symObjAddr: 0x4, symBinAddr: 0x11960, symSize: 0x70 }
-  - { offsetInCU: 0xF6, offset: 0x85A27, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS2ftFZTo', symObjAddr: 0x78, symBinAddr: 0x119D4, symSize: 0x50 }
-  - { offsetInCU: 0x191, offset: 0x85AC2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS4ftFZTo', symObjAddr: 0xCC, symBinAddr: 0x11A28, symSize: 0x68 }
-  - { offsetInCU: 0x254, offset: 0x85B85, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS8ftFZTo', symObjAddr: 0x138, symBinAddr: 0x11A94, symSize: 0x98 }
-  - { offsetInCU: 0x323, offset: 0x85C54, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCACycfcTo', symObjAddr: 0x220, symBinAddr: 0x11B7C, symSize: 0x3C }
-  - { offsetInCU: 0x375, offset: 0x85CA6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCMa', symObjAddr: 0x28C, symBinAddr: 0x11BE8, symSize: 0x20 }
-  - { offsetInCU: 0x4E5, offset: 0x85E16, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x0, symBinAddr: 0x1195C, symSize: 0x4 }
-  - { offsetInCU: 0x51D, offset: 0x85E4E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x0, symBinAddr: 0x1195C, symSize: 0x4 }
-  - { offsetInCU: 0x588, offset: 0x85EB9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS2ftFZ', symObjAddr: 0x74, symBinAddr: 0x119D0, symSize: 0x4 }
-  - { offsetInCU: 0x5C8, offset: 0x85EF9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS2ftFZ', symObjAddr: 0x74, symBinAddr: 0x119D0, symSize: 0x4 }
-  - { offsetInCU: 0x62A, offset: 0x85F5B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS4ftFZ', symObjAddr: 0xC8, symBinAddr: 0x11A24, symSize: 0x4 }
-  - { offsetInCU: 0x67C, offset: 0x85FAD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS4ftFZ', symObjAddr: 0xC8, symBinAddr: 0x11A24, symSize: 0x4 }
-  - { offsetInCU: 0x6F1, offset: 0x86022, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS8ftFZ', symObjAddr: 0x134, symBinAddr: 0x11A90, symSize: 0x4 }
-  - { offsetInCU: 0x767, offset: 0x86098, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS8ftFZ', symObjAddr: 0x134, symBinAddr: 0x11A90, symSize: 0x4 }
-  - { offsetInCU: 0x805, offset: 0x86136, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCACycfC', symObjAddr: 0x1D0, symBinAddr: 0x11B2C, symSize: 0x20 }
-  - { offsetInCU: 0x819, offset: 0x8614A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCACycfc', symObjAddr: 0x1F0, symBinAddr: 0x11B4C, symSize: 0x30 }
-  - { offsetInCU: 0x84F, offset: 0x86180, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCfD', symObjAddr: 0x25C, symBinAddr: 0x11BB8, symSize: 0x30 }
-  - { offsetInCU: 0x27, offset: 0x861CA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC10texImage2Dyys5Int64V_s5Int32VA4HSpys5UInt8VGSuSo6CGSizeVSbtFZ', symObjAddr: 0x0, symBinAddr: 0x11C08, symSize: 0x14 }
-  - { offsetInCU: 0xA9, offset: 0x8624C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC10texImage2Dyys5Int64V_s5Int32VA4HSpys5UInt8VGSuSo6CGSizeVSbtFZTo', symObjAddr: 0x14, symBinAddr: 0x11C1C, symSize: 0x38 }
-  - { offsetInCU: 0x1A2, offset: 0x86345, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC13texSubImage2Dyys5Int64V_s5Int32VA5HSpys5UInt8VGSuSo6CGSizeVSbtFZTo', symObjAddr: 0x68, symBinAddr: 0x11C70, symSize: 0x40 }
-  - { offsetInCU: 0x284, offset: 0x86427, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCACycfcTo', symObjAddr: 0x118, symBinAddr: 0x11D20, symSize: 0x3C }
-  - { offsetInCU: 0x2D6, offset: 0x86479, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCMa', symObjAddr: 0xF8, symBinAddr: 0x11D00, symSize: 0x20 }
-  - { offsetInCU: 0x480, offset: 0x86623, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC10texImage2Dyys5Int64V_s5Int32VA4HSpys5UInt8VGSuSo6CGSizeVSbtFZ', symObjAddr: 0x0, symBinAddr: 0x11C08, symSize: 0x14 }
-  - { offsetInCU: 0x5C4, offset: 0x86767, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC13texSubImage2Dyys5Int64V_s5Int32VA5HSpys5UInt8VGSuSo6CGSizeVSbtFZ', symObjAddr: 0x4C, symBinAddr: 0x11C54, symSize: 0x1C }
-  - { offsetInCU: 0x6FA, offset: 0x8689D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCACycfC', symObjAddr: 0xA8, symBinAddr: 0x11CB0, symSize: 0x20 }
-  - { offsetInCU: 0x70E, offset: 0x868B1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCACycfc', symObjAddr: 0xC8, symBinAddr: 0x11CD0, symSize: 0x30 }
-  - { offsetInCU: 0x744, offset: 0x868E7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCfD', symObjAddr: 0x154, symBinAddr: 0x11D5C, symSize: 0x30 }
-  - { offsetInCU: 0x61, offset: 0x8696B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7isDirtySbvgTo', symObjAddr: 0x4, symBinAddr: 0x11D90, symSize: 0x10 }
-  - { offsetInCU: 0x81, offset: 0x8698B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7isDirtySbvgTo', symObjAddr: 0x4, symBinAddr: 0x11D90, symSize: 0x10 }
-  - { offsetInCU: 0xB7, offset: 0x869C1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7isDirtySbvsTo', symObjAddr: 0x14, symBinAddr: 0x11DA0, symSize: 0x10 }
-  - { offsetInCU: 0xD7, offset: 0x869E1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7isDirtySbvsTo', symObjAddr: 0x14, symBinAddr: 0x11DA0, symSize: 0x10 }
-  - { offsetInCU: 0x110, offset: 0x86A1A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC6canvasAA9NSCCanvasCSgvgTo', symObjAddr: 0x24, symBinAddr: 0x11DB0, symSize: 0x48 }
-  - { offsetInCU: 0x168, offset: 0x86A72, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC6canvasAA9NSCCanvasCSgvsTo', symObjAddr: 0xB4, symBinAddr: 0x11E40, symSize: 0x50 }
-  - { offsetInCU: 0x1C3, offset: 0x86ACD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC3fbos6UInt32VvgTo', symObjAddr: 0x104, symBinAddr: 0x11E90, symSize: 0x10 }
-  - { offsetInCU: 0x1E3, offset: 0x86AED, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC3fbos6UInt32VvgTo', symObjAddr: 0x104, symBinAddr: 0x11E90, symSize: 0x10 }
-  - { offsetInCU: 0x219, offset: 0x86B23, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC3fbos6UInt32VvsTo', symObjAddr: 0x114, symBinAddr: 0x11EA0, symSize: 0x10 }
-  - { offsetInCU: 0x239, offset: 0x86B43, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC3fbos6UInt32VvsTo', symObjAddr: 0x114, symBinAddr: 0x11EA0, symSize: 0x10 }
-  - { offsetInCU: 0x272, offset: 0x86B7C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCACycfcTo', symObjAddr: 0x1B0, symBinAddr: 0x11F3C, symSize: 0x78 }
-  - { offsetInCU: 0x2C8, offset: 0x86BD2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frameACSo6CGRectV_tcfcTo', symObjAddr: 0x2D4, symBinAddr: 0x12060, symSize: 0xB0 }
-  - { offsetInCU: 0x32A, offset: 0x86C34, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5coderACSgSo7NSCoderC_tcfcTo', symObjAddr: 0x43C, symBinAddr: 0x121C8, symSize: 0x28 }
-  - { offsetInCU: 0x35C, offset: 0x86C66, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC12bindDrawableyyFTo', symObjAddr: 0x4E0, symBinAddr: 0x121F0, symSize: 0xA0 }
-  - { offsetInCU: 0x3DD, offset: 0x86CE7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC14deleteDrawableyyFTo', symObjAddr: 0x5BC, symBinAddr: 0x12290, symSize: 0x60 }
-  - { offsetInCU: 0x44D, offset: 0x86D57, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7glkView_6drawInySo0C0C_So6CGRectVtFTo', symObjAddr: 0x620, symBinAddr: 0x122F4, symSize: 0x4C }
-  - { offsetInCU: 0x4BF, offset: 0x86DC9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frame7contextACSo6CGRectV_So11EAGLContextCtcfcTo', symObjAddr: 0x70C, symBinAddr: 0x123E0, symSize: 0x34 }
-  - { offsetInCU: 0x533, offset: 0x86E3D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCMa', symObjAddr: 0x190, symBinAddr: 0x11F1C, symSize: 0x20 }
-  - { offsetInCU: 0x55D, offset: 0x86E67, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCfETo', symObjAddr: 0x74C, symBinAddr: 0x12420, symSize: 0x10 }
-  - { offsetInCU: 0x65B, offset: 0x86F65, size: 0x8, addend: 0x0, symName: '_$sSo7GLKViewC12CanvasNativeE16snapshotWithDatayy10Foundation0F0VFTo', symObjAddr: 0xA08, symBinAddr: 0x126DC, symSize: 0x74 }
-  - { offsetInCU: 0x699, offset: 0x86FA3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC7isDirtySbvgTo', symObjAddr: 0xA7C, symBinAddr: 0x12750, symSize: 0x10 }
-  - { offsetInCU: 0x6B9, offset: 0x86FC3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC7isDirtySbvgTo', symObjAddr: 0xA7C, symBinAddr: 0x12750, symSize: 0x10 }
-  - { offsetInCU: 0x6EF, offset: 0x86FF9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC7isDirtySbvsTo', symObjAddr: 0xA8C, symBinAddr: 0x12760, symSize: 0x10 }
-  - { offsetInCU: 0x70F, offset: 0x87019, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC7isDirtySbvsTo', symObjAddr: 0xA8C, symBinAddr: 0x12760, symSize: 0x10 }
-  - { offsetInCU: 0x748, offset: 0x87052, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC8rendererAA9NSCCanvasCSgvgTo', symObjAddr: 0xA9C, symBinAddr: 0x12770, symSize: 0x20 }
-  - { offsetInCU: 0x7A0, offset: 0x870AA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC8rendererAA9NSCCanvasCSgvsTo', symObjAddr: 0xABC, symBinAddr: 0x12790, symSize: 0x14 }
-  - { offsetInCU: 0x7FB, offset: 0x87105, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvgTo', symObjAddr: 0xAD0, symBinAddr: 0x127A4, symSize: 0x44 }
-  - { offsetInCU: 0x853, offset: 0x8715D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvsTo', symObjAddr: 0xB58, symBinAddr: 0x1282C, symSize: 0x48 }
-  - { offsetInCU: 0x8E8, offset: 0x871F2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCACycfcTo', symObjAddr: 0xCBC, symBinAddr: 0x12990, symSize: 0x78 }
-  - { offsetInCU: 0x93E, offset: 0x87248, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5frameACSo6CGRectV_tcfcTo', symObjAddr: 0xE34, symBinAddr: 0x12B08, symSize: 0xB0 }
-  - { offsetInCU: 0x9A0, offset: 0x872AA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5coderACSgSo7NSCoderC_tcfcTo', symObjAddr: 0xF90, symBinAddr: 0x12C64, symSize: 0x28 }
-  - { offsetInCU: 0x9D2, offset: 0x872DC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC11deviceScaleSfyFTo', symObjAddr: 0xFB8, symBinAddr: 0x12C8C, symSize: 0xB8 }
-  - { offsetInCU: 0xA53, offset: 0x8735D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC4drawyySo6CGRectVFTo', symObjAddr: 0x1074, symBinAddr: 0x12D44, symSize: 0x28 }
-  - { offsetInCU: 0xAB1, offset: 0x873BB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCfETo', symObjAddr: 0x10D8, symBinAddr: 0x12DA8, symSize: 0x10 }
-  - { offsetInCU: 0xC88, offset: 0x87592, size: 0x8, addend: 0x0, symName: '_$ss22_ContiguousArrayBufferV19_uninitializedCount15minimumCapacityAByxGSi_SitcfCs5UInt8V_Tgmq5', symObjAddr: 0x13D0, symBinAddr: 0x12FA4, symSize: 0x64 }
-  - { offsetInCU: 0xCD9, offset: 0x875E3, size: 0x8, addend: 0x0, symName: '_$s10Foundation4DataV15_RepresentationOWOy', symObjAddr: 0x15D8, symBinAddr: 0x131AC, symSize: 0x44 }
-  - { offsetInCU: 0xCED, offset: 0x875F7, size: 0x8, addend: 0x0, symName: '_$s10Foundation4DataV15_RepresentationOWOe', symObjAddr: 0x161C, symBinAddr: 0x131F0, symSize: 0x44 }
-  - { offsetInCU: 0xD01, offset: 0x8760B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCMa', symObjAddr: 0x1660, symBinAddr: 0x13234, symSize: 0x20 }
-  - { offsetInCU: 0xDDB, offset: 0x876E5, size: 0x8, addend: 0x0, symName: '_$sSaySayxGqd__c7ElementQyd__RszSTRd__lufCs5UInt8V_10Foundation4DataVTgm5Tf4g_n', symObjAddr: 0x14B8, symBinAddr: 0x1308C, symSize: 0x110 }
-  - { offsetInCU: 0x1086, offset: 0x87990, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC6canvasAA9NSCCanvasCSgvg', symObjAddr: 0x6C, symBinAddr: 0x11DF8, symSize: 0x48 }
-  - { offsetInCU: 0x1103, offset: 0x87A0D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCACycfc', symObjAddr: 0x124, symBinAddr: 0x11EB0, symSize: 0x6C }
-  - { offsetInCU: 0x114A, offset: 0x87A54, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frameACSo6CGRectV_tcfc', symObjAddr: 0x228, symBinAddr: 0x11FB4, symSize: 0xAC }
-  - { offsetInCU: 0x11AE, offset: 0x87AB8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5coderACSgSo7NSCoderC_tcfc', symObjAddr: 0x384, symBinAddr: 0x12110, symSize: 0xB8 }
-  - { offsetInCU: 0x1239, offset: 0x87B43, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7glkView_6drawInySo0C0C_So6CGRectVtF', symObjAddr: 0x61C, symBinAddr: 0x122F0, symSize: 0x4 }
-  - { offsetInCU: 0x125A, offset: 0x87B64, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frame7contextACSo6CGRectV_So11EAGLContextCtcfC', symObjAddr: 0x66C, symBinAddr: 0x12340, symSize: 0x74 }
-  - { offsetInCU: 0x126E, offset: 0x87B78, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frame7contextACSo6CGRectV_So11EAGLContextCtcfc', symObjAddr: 0x6E0, symBinAddr: 0x123B4, symSize: 0x2C }
-  - { offsetInCU: 0x1387, offset: 0x87C91, size: 0x8, addend: 0x0, symName: '_$sSo7GLKViewC12CanvasNativeE16snapshotWithDatayy10Foundation0F0VF', symObjAddr: 0x75C, symBinAddr: 0x12430, symSize: 0x2AC }
-  - { offsetInCU: 0x1731, offset: 0x8803B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvg', symObjAddr: 0xB14, symBinAddr: 0x127E8, symSize: 0x44 }
-  - { offsetInCU: 0x1770, offset: 0x8807A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvs', symObjAddr: 0xBA0, symBinAddr: 0x12874, symSize: 0x48 }
-  - { offsetInCU: 0x1795, offset: 0x8809F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvM', symObjAddr: 0xBE8, symBinAddr: 0x128BC, symSize: 0x44 }
-  - { offsetInCU: 0x17BA, offset: 0x880C4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvM.resume.0', symObjAddr: 0xC2C, symBinAddr: 0x12900, symSize: 0x4 }
-  - { offsetInCU: 0x17E1, offset: 0x880EB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCACycfC', symObjAddr: 0xC30, symBinAddr: 0x12904, symSize: 0x20 }
-  - { offsetInCU: 0x17F5, offset: 0x880FF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCACycfc', symObjAddr: 0xC50, symBinAddr: 0x12924, symSize: 0x6C }
-  - { offsetInCU: 0x183C, offset: 0x88146, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5frameACSo6CGRectV_tcfc', symObjAddr: 0xD88, symBinAddr: 0x12A5C, symSize: 0xAC }
-  - { offsetInCU: 0x189B, offset: 0x881A5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5coderACSgSo7NSCoderC_tcfc', symObjAddr: 0xEE4, symBinAddr: 0x12BB8, symSize: 0xAC }
-  - { offsetInCU: 0x1940, offset: 0x8824A, size: 0x8, addend: 0x0, symName: '_$ss12_ArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtF12CanvasNative15NSCTouchHandlerC7PointerV_Tg5', symObjAddr: 0x10E8, symBinAddr: 0x12DB8, symSize: 0x104 }
-  - { offsetInCU: 0x1A6F, offset: 0x88379, size: 0x8, addend: 0x0, symName: '_$ss12_ArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtFs5UInt8V_Tg5', symObjAddr: 0x12E8, symBinAddr: 0x12EBC, symSize: 0xE8 }
-  - { offsetInCU: 0x1BB3, offset: 0x884BD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7glkView_6drawInySo0C0C_So6CGRectVtFTf4ddn_n', symObjAddr: 0x1434, symBinAddr: 0x13008, symSize: 0x84 }
-  - { offsetInCU: 0x1CAC, offset: 0x885B6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC4drawyySo6CGRectVFTf4dn_n', symObjAddr: 0x1680, symBinAddr: 0x13254, symSize: 0x360 }
-  - { offsetInCU: 0x2B, offset: 0x889D0, size: 0x8, addend: 0x0, symName: '_$sIegh_IeyBh_TR', symObjAddr: 0x0, symBinAddr: 0x137A0, symSize: 0x2C }
-  - { offsetInCU: 0x4F, offset: 0x889F4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC5queue33_7ED578B0ED4B2B6F6887A622A7B49AA3LLSo012OS_dispatch_E0CvpZ', symObjAddr: 0x958, symBinAddr: 0x10C41B0, symSize: 0x0 }
-  - { offsetInCU: 0x5D, offset: 0x88A02, size: 0x8, addend: 0x0, symName: '_$sIegh_IeyBh_TR', symObjAddr: 0x0, symBinAddr: 0x137A0, symSize: 0x2C }
-  - { offsetInCU: 0x75, offset: 0x88A1A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC5queue33_7ED578B0ED4B2B6F6887A622A7B49AA3LL_WZ', symObjAddr: 0x2C, symBinAddr: 0x137CC, symSize: 0x10C }
-  - { offsetInCU: 0xBC, offset: 0x88A61, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF4SyncySbs5Int64V_So7UIImageCtFZTo', symObjAddr: 0x13C, symBinAddr: 0x138DC, symSize: 0x44 }
-  - { offsetInCU: 0x132, offset: 0x88AD7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZTo', symObjAddr: 0x3AC, symBinAddr: 0x13B4C, symSize: 0x80 }
-  - { offsetInCU: 0x191, offset: 0x88B36, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCACycfcTo', symObjAddr: 0x47C, symBinAddr: 0x13C1C, symSize: 0x3C }
-  - { offsetInCU: 0x1E2, offset: 0x88B87, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZTf4nnnd_n', symObjAddr: 0x4EC, symBinAddr: 0x13C8C, symSize: 0x1DC }
-  - { offsetInCU: 0x269, offset: 0x88C0E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCfETo', symObjAddr: 0x4E8, symBinAddr: 0x13C88, symSize: 0x4 }
-  - { offsetInCU: 0x2A5, offset: 0x88C4A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCMa', symObjAddr: 0x6C8, symBinAddr: 0x13E68, symSize: 0x20 }
-  - { offsetInCU: 0x2C4, offset: 0x88C69, size: 0x8, addend: 0x0, symName: '_$s10ObjectiveC8ObjCBoolVIeyBy_SbIegy_TRTA', symObjAddr: 0x70C, symBinAddr: 0x13EAC, symSize: 0x14 }
-  - { offsetInCU: 0x2ED, offset: 0x88C92, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_TA', symObjAddr: 0x74C, symBinAddr: 0x13EEC, symSize: 0xC }
-  - { offsetInCU: 0x301, offset: 0x88CA6, size: 0x8, addend: 0x0, symName: _block_copy_helper, symObjAddr: 0x758, symBinAddr: 0x13EF8, symSize: 0x10 }
-  - { offsetInCU: 0x315, offset: 0x88CBA, size: 0x8, addend: 0x0, symName: _block_destroy_helper, symObjAddr: 0x768, symBinAddr: 0x13F08, symSize: 0x8 }
-  - { offsetInCU: 0x329, offset: 0x88CCE, size: 0x8, addend: 0x0, symName: '_$s8Dispatch0A13WorkItemFlagsVACs10SetAlgebraAAWl', symObjAddr: 0x770, symBinAddr: 0x13F10, symSize: 0x48 }
-  - { offsetInCU: 0x33D, offset: 0x88CE2, size: 0x8, addend: 0x0, symName: '_$sSay8Dispatch0A13WorkItemFlagsVGSayxGSTsWl', symObjAddr: 0x7F8, symBinAddr: 0x13F58, symSize: 0x4C }
-  - { offsetInCU: 0x351, offset: 0x88CF6, size: 0x8, addend: 0x0, symName: ___swift_instantiateConcreteTypeFromMangledNameAbstract, symObjAddr: 0x844, symBinAddr: 0x13FA4, symSize: 0x44 }
-  - { offsetInCU: 0x365, offset: 0x88D0A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_yyScMYccfU0_TA', symObjAddr: 0x8C4, symBinAddr: 0x13FE8, symSize: 0x24 }
-  - { offsetInCU: 0x399, offset: 0x88D3E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_yyScMYccfU_TA', symObjAddr: 0x90C, symBinAddr: 0x14030, symSize: 0x24 }
-  - { offsetInCU: 0x52E, offset: 0x88ED3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF4SyncySbs5Int64V_So7UIImageCtFZ', symObjAddr: 0x138, symBinAddr: 0x138D8, symSize: 0x4 }
-  - { offsetInCU: 0x55C, offset: 0x88F01, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF4SyncySbs5Int64V_So7UIImageCtFZ', symObjAddr: 0x138, symBinAddr: 0x138D8, symSize: 0x4 }
-  - { offsetInCU: 0x5BB, offset: 0x88F60, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZ', symObjAddr: 0x180, symBinAddr: 0x13920, symSize: 0x4 }
-  - { offsetInCU: 0x5CF, offset: 0x88F74, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_', symObjAddr: 0x184, symBinAddr: 0x13924, symSize: 0x228 }
-  - { offsetInCU: 0x6A8, offset: 0x8904D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCACycfC', symObjAddr: 0x42C, symBinAddr: 0x13BCC, symSize: 0x20 }
-  - { offsetInCU: 0x6BC, offset: 0x89061, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCACycfc', symObjAddr: 0x44C, symBinAddr: 0x13BEC, symSize: 0x30 }
-  - { offsetInCU: 0x6F2, offset: 0x89097, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCfD', symObjAddr: 0x4B8, symBinAddr: 0x13C58, symSize: 0x30 }
-  - { offsetInCU: 0x27, offset: 0x8913D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfC', symObjAddr: 0x0, symBinAddr: 0x14068, symSize: 0x20 }
-  - { offsetInCU: 0x77, offset: 0x8918D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfcTo', symObjAddr: 0x70, symBinAddr: 0x140D8, symSize: 0x3C }
-  - { offsetInCU: 0xC9, offset: 0x891DF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCMa', symObjAddr: 0x50, symBinAddr: 0x140B8, symSize: 0x20 }
-  - { offsetInCU: 0x214, offset: 0x8932A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfC', symObjAddr: 0x0, symBinAddr: 0x14068, symSize: 0x20 }
-  - { offsetInCU: 0x228, offset: 0x8933E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfc', symObjAddr: 0x20, symBinAddr: 0x14088, symSize: 0x30 }
-  - { offsetInCU: 0x264, offset: 0x8937A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCfD', symObjAddr: 0xAC, symBinAddr: 0x14114, symSize: 0x30 }
-  - { offsetInCU: 0x26, offset: 0x893C3, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_frombytes_vartime, symObjAddr: 0x0, symBinAddr: 0x2B1E9C, symSize: 0x265C }
-  - { offsetInCU: 0x40, offset: 0x893DD, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_k25519Precomp, symObjAddr: 0x9E20, symBinAddr: 0x9951C0, symSize: 0x0 }
-  - { offsetInCU: 0x92, offset: 0x8942F, size: 0x8, addend: 0x0, symName: _d, symObjAddr: 0xFE20, symBinAddr: 0x99B1C0, symSize: 0x0 }
-  - { offsetInCU: 0xF6, offset: 0x89493, size: 0x8, addend: 0x0, symName: _sqrtm1, symObjAddr: 0xFE48, symBinAddr: 0x99B1E8, symSize: 0x0 }
-  - { offsetInCU: 0x10C, offset: 0x894A9, size: 0x8, addend: 0x0, symName: _d2, symObjAddr: 0x10250, symBinAddr: 0x99B5F0, symSize: 0x0 }
-  - { offsetInCU: 0x123, offset: 0x894C0, size: 0x8, addend: 0x0, symName: _Bi, symObjAddr: 0xFE90, symBinAddr: 0x99B230, symSize: 0x0 }
-  - { offsetInCU: 0x9C2, offset: 0x89D5F, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_frombytes_vartime, symObjAddr: 0x0, symBinAddr: 0x2B1E9C, symSize: 0x265C }
-  - { offsetInCU: 0x45D1, offset: 0x8D96E, size: 0x8, addend: 0x0, symName: _fe_frombytes, symObjAddr: 0x265C, symBinAddr: 0x2B44F8, symSize: 0x134 }
-  - { offsetInCU: 0x46F7, offset: 0x8DA94, size: 0x8, addend: 0x0, symName: _fe_mul_impl, symObjAddr: 0x9954, symBinAddr: 0x2BB7F0, symSize: 0x21C }
-  - { offsetInCU: 0x4926, offset: 0x8DCC3, size: 0x8, addend: 0x0, symName: _fe_tobytes, symObjAddr: 0x4FE0, symBinAddr: 0x2B6E7C, symSize: 0x1B8 }
-  - { offsetInCU: 0x5313, offset: 0x8E6B0, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_scalarmult_base, symObjAddr: 0x2790, symBinAddr: 0x2B462C, symSize: 0x5BC }
-  - { offsetInCU: 0x5F76, offset: 0x8F313, size: 0x8, addend: 0x0, symName: _table_select, symObjAddr: 0x2D4C, symBinAddr: 0x2B4BE8, symSize: 0x7F8 }
-  - { offsetInCU: 0x642E, offset: 0x8F7CB, size: 0x8, addend: 0x0, symName: _ge_madd, symObjAddr: 0x3544, symBinAddr: 0x2B53E0, symSize: 0x208 }
-  - { offsetInCU: 0x69FC, offset: 0x8FD99, size: 0x8, addend: 0x0, symName: _ge_p2_dbl, symObjAddr: 0x374C, symBinAddr: 0x2B55E8, symSize: 0x7B4 }
-  - { offsetInCU: 0x77D5, offset: 0x90B72, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_sc_reduce, symObjAddr: 0x3F00, symBinAddr: 0x2B5D9C, symSize: 0x634 }
-  - { offsetInCU: 0x8196, offset: 0x91533, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_scalar_mult_generic_masked, symObjAddr: 0x4534, symBinAddr: 0x2B63D0, symSize: 0xAAC }
-  - { offsetInCU: 0x9567, offset: 0x92904, size: 0x8, addend: 0x0, symName: _fe_loose_invert, symObjAddr: 0x529C, symBinAddr: 0x2B7138, symSize: 0x23F8 }
-  - { offsetInCU: 0xCAB8, offset: 0x95E55, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_public_from_private_generic_masked, symObjAddr: 0x5198, symBinAddr: 0x2B7034, symSize: 0x104 }
-  - { offsetInCU: 0xCD20, offset: 0x960BD, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_invert, symObjAddr: 0x7694, symBinAddr: 0x2B9530, symSize: 0x30 }
-  - { offsetInCU: 0xCE11, offset: 0x961AE, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_isnegative, symObjAddr: 0x76C4, symBinAddr: 0x2B9560, symSize: 0x58 }
-  - { offsetInCU: 0xCE86, offset: 0x96223, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_mul_ttt, symObjAddr: 0x771C, symBinAddr: 0x2B95B8, symSize: 0x4 }
-  - { offsetInCU: 0xCECE, offset: 0x9626B, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_mul_ttt, symObjAddr: 0x771C, symBinAddr: 0x2B95B8, symSize: 0x4 }
-  - { offsetInCU: 0xCEFD, offset: 0x9629A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_mul_ttt, symObjAddr: 0x771C, symBinAddr: 0x2B95B8, symSize: 0x4 }
-  - { offsetInCU: 0xCF21, offset: 0x962BE, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_neg, symObjAddr: 0x7720, symBinAddr: 0x2B95BC, symSize: 0x8C }
-  - { offsetInCU: 0xD056, offset: 0x963F3, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_tobytes, symObjAddr: 0x77AC, symBinAddr: 0x2B9648, symSize: 0x4 }
-  - { offsetInCU: 0xD08F, offset: 0x9642C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_tobytes, symObjAddr: 0x77AC, symBinAddr: 0x2B9648, symSize: 0x4 }
-  - { offsetInCU: 0xD328, offset: 0x966C5, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_double_scalarmult_vartime, symObjAddr: 0x77B0, symBinAddr: 0x2B964C, symSize: 0x15D8 }
-  - { offsetInCU: 0x10671, offset: 0x99A0E, size: 0x8, addend: 0x0, symName: _x25519_ge_add, symObjAddr: 0x9B70, symBinAddr: 0x2BBA0C, symSize: 0x218 }
-  - { offsetInCU: 0x10CA3, offset: 0x9A040, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_sc_mask, symObjAddr: 0x8D88, symBinAddr: 0x2BAC24, symSize: 0x20 }
-  - { offsetInCU: 0x11140, offset: 0x9A4DD, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_sc_muladd, symObjAddr: 0x8DA8, symBinAddr: 0x2BAC44, symSize: 0xBAC }
-  - { offsetInCU: 0x26, offset: 0x9B2A8, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_from_montgomery_in_place, symObjAddr: 0x0, symBinAddr: 0x2BBC24, symSize: 0x1F4 }
-  - { offsetInCU: 0x1D2, offset: 0x9B454, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_from_montgomery_in_place, symObjAddr: 0x0, symBinAddr: 0x2BBC24, symSize: 0x1F4 }
-  - { offsetInCU: 0x26, offset: 0x9B6EF, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_neg_inv_mod_r_u64, symObjAddr: 0x0, symBinAddr: 0x2BBE18, symSize: 0x3C }
-  - { offsetInCU: 0x34, offset: 0x9B6FD, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_neg_inv_mod_r_u64, symObjAddr: 0x0, symBinAddr: 0x2BBE18, symSize: 0x3C }
-  - { offsetInCU: 0x26, offset: 0x9B80D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_little_endian_bytes_from_scalar, symObjAddr: 0x0, symBinAddr: 0x2BBE54, symSize: 0x98 }
-  - { offsetInCU: 0x34, offset: 0x9B81B, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_little_endian_bytes_from_scalar, symObjAddr: 0x0, symBinAddr: 0x2BBE54, symSize: 0x98 }
-  - { offsetInCU: 0x86, offset: 0x9B97E, size: 0x8, addend: 0x0, symName: _Q_N0, symObjAddr: 0x1100, symBinAddr: 0x99B6A0, symSize: 0x0 }
-  - { offsetInCU: 0xB8, offset: 0x9B9B0, size: 0x8, addend: 0x0, symName: _Q, symObjAddr: 0x1090, symBinAddr: 0x99B630, symSize: 0x0 }
-  - { offsetInCU: 0xDA, offset: 0x9B9D2, size: 0x8, addend: 0x0, symName: _N, symObjAddr: 0x10C0, symBinAddr: 0x99B660, symSize: 0x0 }
-  - { offsetInCU: 0xF0, offset: 0x9B9E8, size: 0x8, addend: 0x0, symName: _N_N0, symObjAddr: 0x10F0, symBinAddr: 0x99B690, symSize: 0x0 }
-  - { offsetInCU: 0x3B7, offset: 0x9BCAF, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_elem_mul_mont, symObjAddr: 0x100, symBinAddr: 0x2BBEEC, symSize: 0x18 }
-  - { offsetInCU: 0x3FB, offset: 0x9BCF3, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_elem_mul_mont, symObjAddr: 0x100, symBinAddr: 0x2BBEEC, symSize: 0x18 }
-  - { offsetInCU: 0x594, offset: 0x9BE8C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_scalar_mul_mont, symObjAddr: 0x1F8, symBinAddr: 0x2BBF04, symSize: 0x18 }
-  - { offsetInCU: 0x63F, offset: 0x9BF37, size: 0x8, addend: 0x0, symName: _nistz384_point_double, symObjAddr: 0x290, symBinAddr: 0x2BBF1C, symSize: 0x320 }
-  - { offsetInCU: 0x1173, offset: 0x9CA6B, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_point_add, symObjAddr: 0x5B0, symBinAddr: 0x2BC23C, symSize: 0xAC }
-  - { offsetInCU: 0x1469, offset: 0x9CD61, size: 0x8, addend: 0x0, symName: _nistz384_point_add, symObjAddr: 0x65C, symBinAddr: 0x2BC2E8, symSize: 0x500 }
-  - { offsetInCU: 0x2666, offset: 0x9DF5E, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_point_mul, symObjAddr: 0xB5C, symBinAddr: 0x2BC7E8, symSize: 0x2C8 }
-  - { offsetInCU: 0x2CB5, offset: 0x9E5AD, size: 0x8, addend: 0x0, symName: _p384_point_select_w5, symObjAddr: 0xE24, symBinAddr: 0x2BCAB0, symSize: 0xF4 }
-  - { offsetInCU: 0x2EC7, offset: 0x9E7BF, size: 0x8, addend: 0x0, symName: _add_precomputed_w5, symObjAddr: 0xF18, symBinAddr: 0x2BCBA4, symSize: 0x168 }
-  - { offsetInCU: 0x26, offset: 0x9EAEA, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_zero, symObjAddr: 0x0, symBinAddr: 0x2BCD0C, symSize: 0x38 }
-  - { offsetInCU: 0xFA, offset: 0x9EBBE, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_zero, symObjAddr: 0x0, symBinAddr: 0x2BCD0C, symSize: 0x38 }
-  - { offsetInCU: 0x12C, offset: 0x9EBF0, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_zero, symObjAddr: 0x0, symBinAddr: 0x2BCD0C, symSize: 0x38 }
-  - { offsetInCU: 0x199, offset: 0x9EC5D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_equal, symObjAddr: 0x38, symBinAddr: 0x2BCD44, symSize: 0x3C }
-  - { offsetInCU: 0x1F3, offset: 0x9ECB7, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_equal, symObjAddr: 0x38, symBinAddr: 0x2BCD44, symSize: 0x3C }
-  - { offsetInCU: 0x31B, offset: 0x9EDDF, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_equal_limb, symObjAddr: 0x74, symBinAddr: 0x2BCD80, symSize: 0x5C }
-  - { offsetInCU: 0x517, offset: 0x9EFDB, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_even, symObjAddr: 0xD0, symBinAddr: 0x2BCDDC, symSize: 0x1C }
-  - { offsetInCU: 0x636, offset: 0x9F0FA, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_less_than, symObjAddr: 0xEC, symBinAddr: 0x2BCDF8, symSize: 0x54 }
-  - { offsetInCU: 0x6D9, offset: 0x9F19D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_less_than_limb, symObjAddr: 0x140, symBinAddr: 0x2BCE4C, symSize: 0x4C }
-  - { offsetInCU: 0x8A7, offset: 0x9F36B, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_reduce_once, symObjAddr: 0x18C, symBinAddr: 0x2BCE98, symSize: 0xA8 }
-  - { offsetInCU: 0x90B, offset: 0x9F3CF, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_reduce_once, symObjAddr: 0x18C, symBinAddr: 0x2BCE98, symSize: 0xA8 }
-  - { offsetInCU: 0xBAA, offset: 0x9F66E, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_add_mod, symObjAddr: 0x234, symBinAddr: 0x2BCF40, symSize: 0x110 }
-  - { offsetInCU: 0xC4C, offset: 0x9F710, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_add_mod, symObjAddr: 0x234, symBinAddr: 0x2BCF40, symSize: 0x110 }
-  - { offsetInCU: 0xEDE, offset: 0x9F9A2, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_sub_mod, symObjAddr: 0x344, symBinAddr: 0x2BD050, symSize: 0xB0 }
-  - { offsetInCU: 0xF5E, offset: 0x9FA22, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_sub_mod, symObjAddr: 0x344, symBinAddr: 0x2BD050, symSize: 0xB0 }
-  - { offsetInCU: 0x10E1, offset: 0x9FBA5, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_shl_mod, symObjAddr: 0x3F4, symBinAddr: 0x2BD100, symSize: 0x198 }
-  - { offsetInCU: 0x13AB, offset: 0x9FE6F, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_select_512_32, symObjAddr: 0x58C, symBinAddr: 0x2BD298, symSize: 0x290 }
-  - { offsetInCU: 0x1500, offset: 0x9FFC4, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_window5_split_window, symObjAddr: 0x81C, symBinAddr: 0x2BD528, symSize: 0x18 }
-  - { offsetInCU: 0x1567, offset: 0xA002B, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_window5_unsplit_window, symObjAddr: 0x834, symBinAddr: 0x2BD540, symSize: 0xC }
-  - { offsetInCU: 0x15A0, offset: 0xA0064, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMB_shr, symObjAddr: 0x840, symBinAddr: 0x2BD54C, symSize: 0x8 }
-  - { offsetInCU: 0x1624, offset: 0xA00E8, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_limbs_mul_add_limb, symObjAddr: 0x848, symBinAddr: 0x2BD554, symSize: 0x3C }
-  - { offsetInCU: 0x26, offset: 0xA029B, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_CRYPTO_memcmp, symObjAddr: 0x0, symBinAddr: 0x2BD590, symSize: 0x190 }
-  - { offsetInCU: 0x34, offset: 0xA02A9, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_CRYPTO_memcmp, symObjAddr: 0x0, symBinAddr: 0x2BD590, symSize: 0x190 }
-  - { offsetInCU: 0x34, offset: 0xA03AF, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_OPENSSL_armcap_P, symObjAddr: 0x398, symBinAddr: 0x10CB0D8, symSize: 0x0 }
-  - { offsetInCU: 0x26, offset: 0xA03F1, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul, symObjAddr: 0x0, symBinAddr: 0x2BD720, symSize: 0x388 }
-  - { offsetInCU: 0x76, offset: 0xA0441, size: 0x8, addend: 0x0, symName: _ecp_nistz256_precomputed, symObjAddr: 0x1000, symBinAddr: 0x99C000, symSize: 0x0 }
-  - { offsetInCU: 0xFA, offset: 0xA04C5, size: 0x8, addend: 0x0, symName: _ONE, symObjAddr: 0x26000, symBinAddr: 0x9C1000, symSize: 0x0 }
-  - { offsetInCU: 0x35B, offset: 0xA0726, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul, symObjAddr: 0x0, symBinAddr: 0x2BD720, symSize: 0x388 }
-  - { offsetInCU: 0xC66, offset: 0xA1031, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul_base, symObjAddr: 0x388, symBinAddr: 0x2BDAA8, symSize: 0x204 }
-  - { offsetInCU: 0x1163, offset: 0xA152E, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul_base_vartime, symObjAddr: 0x58C, symBinAddr: 0x2BDCAC, symSize: 0x1BC }
-  - { offsetInCU: 0x10, offset: 0xA1903, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_set_encrypt_key, symObjAddr: 0x0, symBinAddr: 0x2BDE80, symSize: 0x1A0 }
-  - { offsetInCU: 0x50, offset: 0xA1943, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_set_encrypt_key, symObjAddr: 0x0, symBinAddr: 0x2BDE80, symSize: 0x1A0 }
-  - { offsetInCU: 0x5E, offset: 0xA1951, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_encrypt, symObjAddr: 0x1A0, symBinAddr: 0x2BE020, symSize: 0x60 }
-  - { offsetInCU: 0x81, offset: 0xA1974, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_ctr32_encrypt_blocks, symObjAddr: 0x200, symBinAddr: 0x2BE080, symSize: 0x288 }
-  - { offsetInCU: 0x10, offset: 0xA1965, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_init_clmul, symObjAddr: 0x0, symBinAddr: 0x2BE310, symSize: 0x130 }
-  - { offsetInCU: 0x48, offset: 0xA199D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_init_clmul, symObjAddr: 0x0, symBinAddr: 0x2BE310, symSize: 0x130 }
-  - { offsetInCU: 0x5F, offset: 0xA19B4, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_gmult_clmul, symObjAddr: 0x130, symBinAddr: 0x2BE440, symSize: 0x70 }
-  - { offsetInCU: 0x75, offset: 0xA19CA, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_ghash_clmul, symObjAddr: 0x1A0, symBinAddr: 0x2BE4B0, symSize: 0x160 }
-  - { offsetInCU: 0x7A, offset: 0xA19CF, size: 0x8, addend: 0x0, symName: gcm_ghash_v8_4x, symObjAddr: 0x300, symBinAddr: 0x2BE610, symSize: 0x378 }
-  - { offsetInCU: 0x10, offset: 0xA19DD, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ChaCha20_ctr32, symObjAddr: 0x0, symBinAddr: 0x2BE9A0, symSize: 0x3A0 }
-  - { offsetInCU: 0x48, offset: 0xA1A15, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ChaCha20_ctr32, symObjAddr: 0x0, symBinAddr: 0x2BE9A0, symSize: 0x3A0 }
-  - { offsetInCU: 0x4C, offset: 0xA1A19, size: 0x8, addend: 0x0, symName: ChaCha20_neon, symObjAddr: 0x3A0, symBinAddr: 0x2BED40, symSize: 0x6C0 }
-  - { offsetInCU: 0x66, offset: 0xA1A33, size: 0x8, addend: 0x0, symName: ChaCha20_512_neon, symObjAddr: 0xA60, symBinAddr: 0x2BF400, symSize: 0x1138 }
-  - { offsetInCU: 0x50, offset: 0xA1A7F, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_chacha20_poly1305_seal, symObjAddr: 0x140, symBinAddr: 0x2C0680, symSize: 0x1180 }
-  - { offsetInCU: 0x66, offset: 0xA1A95, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_chacha20_poly1305_open, symObjAddr: 0x12C0, symBinAddr: 0x2C1800, symSize: 0x1410 }
-  - { offsetInCU: 0x10, offset: 0xA1A8B, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_mul_mont, symObjAddr: 0x0, symBinAddr: 0x2C2C20, symSize: 0x240 }
-  - { offsetInCU: 0x45, offset: 0xA1AC0, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_mul_mont, symObjAddr: 0x0, symBinAddr: 0x2C2C20, symSize: 0x240 }
-  - { offsetInCU: 0x4D, offset: 0xA1AC8, size: 0x8, addend: 0x0, symName: __bn_sqr8x_mont, symObjAddr: 0x240, symBinAddr: 0x2C2E60, symSize: 0x9E0 }
-  - { offsetInCU: 0x63, offset: 0xA1ADE, size: 0x8, addend: 0x0, symName: __bn_mul4x_mont, symObjAddr: 0xC20, symBinAddr: 0x2C3840, symSize: 0x650 }
-  - { offsetInCU: 0x10, offset: 0xA1AED, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_mul_mont, symObjAddr: 0x0, symBinAddr: 0x2C3EA0, symSize: 0x40 }
-  - { offsetInCU: 0x47, offset: 0xA1B24, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_mul_mont, symObjAddr: 0x0, symBinAddr: 0x2C3EA0, symSize: 0x40 }
-  - { offsetInCU: 0x5D, offset: 0xA1B3A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_sqr_mont, symObjAddr: 0x40, symBinAddr: 0x2C3EE0, symSize: 0x40 }
-  - { offsetInCU: 0x76, offset: 0xA1B53, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ecp_nistz256_neg, symObjAddr: 0x80, symBinAddr: 0x2C3F20, symSize: 0x40 }
-  - { offsetInCU: 0x81, offset: 0xA1B5E, size: 0x8, addend: 0x0, symName: __ecp_nistz256_mul_mont, symObjAddr: 0xC0, symBinAddr: 0x2C3F60, symSize: 0x1E0 }
-  - { offsetInCU: 0x97, offset: 0xA1B74, size: 0x8, addend: 0x0, symName: __ecp_nistz256_sqr_mont, symObjAddr: 0x2A0, symBinAddr: 0x2C4140, symSize: 0x170 }
-  - { offsetInCU: 0xAB, offset: 0xA1B88, size: 0x8, addend: 0x0, symName: __ecp_nistz256_add_to, symObjAddr: 0x410, symBinAddr: 0x2C42B0, symSize: 0x50 }
-  - { offsetInCU: 0xC3, offset: 0xA1BA0, size: 0x8, addend: 0x0, symName: __ecp_nistz256_sub_from, symObjAddr: 0x460, symBinAddr: 0x2C4300, symSize: 0x50 }
-  - { offsetInCU: 0xD9, offset: 0xA1BB6, size: 0x8, addend: 0x0, symName: __ecp_nistz256_sub_morf, symObjAddr: 0x4B0, symBinAddr: 0x2C4350, symSize: 0x50 }
-  - { offsetInCU: 0xEF, offset: 0xA1BCC, size: 0x8, addend: 0x0, symName: __ecp_nistz256_div_by_2, symObjAddr: 0x500, symBinAddr: 0x2C43A0, symSize: 0x60 }
-  - { offsetInCU: 0x111, offset: 0xA1BEE, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_double, symObjAddr: 0x560, symBinAddr: 0x2C4400, symSize: 0x1E0 }
-  - { offsetInCU: 0x124, offset: 0xA1C01, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_add, symObjAddr: 0x740, symBinAddr: 0x2C45E0, symSize: 0x360 }
-  - { offsetInCU: 0x141, offset: 0xA1C1E, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_add_affine, symObjAddr: 0xAA0, symBinAddr: 0x2C4940, symSize: 0x2D0 }
-  - { offsetInCU: 0x156, offset: 0xA1C33, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_scalar_mul_mont, symObjAddr: 0xD70, symBinAddr: 0x2C4C10, symSize: 0x2B0 }
-  - { offsetInCU: 0x170, offset: 0xA1C4D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_scalar_sqr_rep_mont, symObjAddr: 0x1020, symBinAddr: 0x2C4EC0, symSize: 0x250 }
-  - { offsetInCU: 0x184, offset: 0xA1C61, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ecp_nistz256_select_w5, symObjAddr: 0x1270, symBinAddr: 0x2C5110, symSize: 0x60 }
-  - { offsetInCU: 0x19A, offset: 0xA1C77, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ecp_nistz256_select_w7, symObjAddr: 0x12D0, symBinAddr: 0x2C5170, symSize: 0x44 }
-  - { offsetInCU: 0x10, offset: 0xA1C6D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_gcm_enc_kernel, symObjAddr: 0x0, symBinAddr: 0x2C51C0, symSize: 0xB90 }
-  - { offsetInCU: 0x4C, offset: 0xA1CA9, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_gcm_enc_kernel, symObjAddr: 0x0, symBinAddr: 0x2C51C0, symSize: 0xB90 }
-  - { offsetInCU: 0x62, offset: 0xA1CBF, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_gcm_dec_kernel, symObjAddr: 0xB90, symBinAddr: 0x2C5D50, symSize: 0xB98 }
-  - { offsetInCU: 0x10, offset: 0xA1CB9, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha512_block_data_order, symObjAddr: 0x0, symBinAddr: 0x2C6900, symSize: 0xE40 }
-  - { offsetInCU: 0x51, offset: 0xA1CFA, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha512_block_data_order, symObjAddr: 0x0, symBinAddr: 0x2C6900, symSize: 0xE40 }
-  - { offsetInCU: 0x51, offset: 0xA1CFA, size: 0x8, addend: 0x0, symName: sha512_block_armv8, symObjAddr: 0xE40, symBinAddr: 0x2C7740, symSize: 0x7E0 }
-  - { offsetInCU: 0x10, offset: 0xA1D05, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha256_block_data_order, symObjAddr: 0x0, symBinAddr: 0x2C7F40, symSize: 0xE40 }
-  - { offsetInCU: 0x51, offset: 0xA1D46, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha256_block_data_order, symObjAddr: 0x0, symBinAddr: 0x2C7F40, symSize: 0xE40 }
-  - { offsetInCU: 0x51, offset: 0xA1D46, size: 0x8, addend: 0x0, symName: sha256_block_armv8, symObjAddr: 0xE40, symBinAddr: 0x2C8D80, symSize: 0x1F0 }
+  - { offsetInCU: 0x34, offset: 0x77D9B, size: 0x8, addend: 0x0, symName: _CanvasNativeVersionString, symObjAddr: 0x0, symBinAddr: 0x955000, symSize: 0x0 }
+  - { offsetInCU: 0x69, offset: 0x77DD0, size: 0x8, addend: 0x0, symName: _CanvasNativeVersionNumber, symObjAddr: 0x38, symBinAddr: 0x955038, symSize: 0x0 }
+  - { offsetInCU: 0x3F, offset: 0x77E25, size: 0x8, addend: 0x0, symName: ___swift_memcpy16_8, symObjAddr: 0x28, symBinAddr: 0x5268, symSize: 0xC }
+  - { offsetInCU: 0x53, offset: 0x77E39, size: 0x8, addend: 0x0, symName: ___swift_noop_void_return, symObjAddr: 0x34, symBinAddr: 0x5274, symSize: 0x4 }
+  - { offsetInCU: 0x67, offset: 0x77E4D, size: 0x8, addend: 0x0, symName: '_$sSo6CGSizeVwet', symObjAddr: 0x38, symBinAddr: 0x5278, symSize: 0x20 }
+  - { offsetInCU: 0x7B, offset: 0x77E61, size: 0x8, addend: 0x0, symName: '_$sSo6CGSizeVwst', symObjAddr: 0x58, symBinAddr: 0x5298, symSize: 0x28 }
+  - { offsetInCU: 0x8F, offset: 0x77E75, size: 0x8, addend: 0x0, symName: '_$sSo6CGRectVwCP', symObjAddr: 0x94, symBinAddr: 0x52D4, symSize: 0x30 }
+  - { offsetInCU: 0xA3, offset: 0x77E89, size: 0x8, addend: 0x0, symName: ___swift_memcpy32_8, symObjAddr: 0xC4, symBinAddr: 0x5304, symSize: 0xC }
+  - { offsetInCU: 0xB7, offset: 0x77E9D, size: 0x8, addend: 0x0, symName: '_$sSo6CGRectVwet', symObjAddr: 0xD0, symBinAddr: 0x5310, symSize: 0x20 }
+  - { offsetInCU: 0xCB, offset: 0x77EB1, size: 0x8, addend: 0x0, symName: '_$sSo6CGRectVwst', symObjAddr: 0xF0, symBinAddr: 0x5330, symSize: 0x2C }
+  - { offsetInCU: 0x4F, offset: 0x7809A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC11_WriteQueue33_05178D28796EA758448493B56DC45144LLSo011NSOperationE0CSgvpZ', symObjAddr: 0x2AE8, symBinAddr: 0x114FD10, symSize: 0x0 }
+  - { offsetInCU: 0x69, offset: 0x780B4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10_ReadQueue33_05178D28796EA758448493B56DC45144LLSo011NSOperationE0CSgvpZ', symObjAddr: 0x2AF0, symBinAddr: 0x114FD18, symSize: 0x0 }
+  - { offsetInCU: 0x9D, offset: 0x780E8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC19getBytesFromUIImageySo13NSMutableDataCSo0G0CFZTo', symObjAddr: 0x4, symBinAddr: 0x53D4, symSize: 0x38 }
+  - { offsetInCU: 0xF3, offset: 0x7813E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13createPatternys5Int64VAF_So7UIImageCSStFZTo', symObjAddr: 0x40, symBinAddr: 0x5410, symSize: 0x70 }
+  - { offsetInCU: 0x144, offset: 0x7818F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC25loadImageAssetWithContextySbs5Int64V_So7UIImageCtFZTo', symObjAddr: 0xB4, symBinAddr: 0x5484, symSize: 0x44 }
+  - { offsetInCU: 0x19F, offset: 0x781EA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dyys5Int64V_So7UIImageCS2ftFZTo', symObjAddr: 0xFC, symBinAddr: 0x54CC, symSize: 0x50 }
+  - { offsetInCU: 0x204, offset: 0x7824F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dy2dw2dhys5Int64V_So7UIImageCS4ftFZTo', symObjAddr: 0x150, symBinAddr: 0x5520, symSize: 0x68 }
+  - { offsetInCU: 0x27D, offset: 0x782C8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2sx2sy2sw2sh2dx2dy2dw2dhys5Int64V_So7UIImageCS8ftFZTo', symObjAddr: 0x1BC, symBinAddr: 0x558C, symSize: 0x98 }
+  - { offsetInCU: 0x2DA, offset: 0x78325, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23initWebGPUWithViewLayerys5Int64VAF_AFs6UInt32VAHtFZTo', symObjAddr: 0x258, symBinAddr: 0x5628, symSize: 0x14 }
+  - { offsetInCU: 0x35C, offset: 0x783A7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC18initWebGPUWithViewys5Int64VAF_AFs6UInt32VAHtFZTo', symObjAddr: 0x270, symBinAddr: 0x5640, symSize: 0x14 }
+  - { offsetInCU: 0x40B, offset: 0x78456, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14initGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbtFZTo', symObjAddr: 0x2C8, symBinAddr: 0x5698, symSize: 0x50 }
+  - { offsetInCU: 0x4DC, offset: 0x78527, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC20initSharedGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbAFtFZTo', symObjAddr: 0x364, symBinAddr: 0x5734, symSize: 0x58 }
+  - { offsetInCU: 0x5B6, offset: 0x78601, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC24initGLWithWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbtFZTo', symObjAddr: 0x404, symBinAddr: 0x57D4, symSize: 0x58 }
+  - { offsetInCU: 0x695, offset: 0x786E0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC26initSharedGLWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbAFtFZTo', symObjAddr: 0x4AC, symBinAddr: 0x587C, symSize: 0x60 }
+  - { offsetInCU: 0x741, offset: 0x7878C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15resize2DContextyys5Int64V_S2ftFZTo', symObjAddr: 0x510, symBinAddr: 0x58E0, symSize: 0x8 }
+  - { offsetInCU: 0x7AA, offset: 0x787F5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14flush2DContextyys5Int64VFZTo', symObjAddr: 0x51C, symBinAddr: 0x58EC, symSize: 0x8 }
+  - { offsetInCU: 0x801, offset: 0x7884C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC7flushGLySbs5Int64VFZTo', symObjAddr: 0x538, symBinAddr: 0x5908, symSize: 0x8 }
+  - { offsetInCU: 0x858, offset: 0x788A3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9releaseGLyys5Int64VFZTo', symObjAddr: 0x544, symBinAddr: 0x5914, symSize: 0x8 }
+  - { offsetInCU: 0x8AF, offset: 0x788FA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC12getGLPointerys5Int64VAFFZTo', symObjAddr: 0x550, symBinAddr: 0x5920, symSize: 0x8 }
+  - { offsetInCU: 0x906, offset: 0x78951, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC16releaseGLPointeryys5Int64VFZTo', symObjAddr: 0x55C, symBinAddr: 0x592C, symSize: 0x8 }
+  - { offsetInCU: 0x985, offset: 0x789D0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15create2DContextys5Int64VAF_s5Int32VAHSbSfA2HSfAHtFZTo', symObjAddr: 0x56C, symBinAddr: 0x593C, symSize: 0x24 }
+  - { offsetInCU: 0xA36, offset: 0x78A81, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23updateGLSurfaceWithViewyys5Int64V_s5Int32VAhFtFZTo', symObjAddr: 0x594, symBinAddr: 0x5964, symSize: 0x14 }
+  - { offsetInCU: 0xAA9, offset: 0x78AF4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC6test2Dyys5Int64VFZTo', symObjAddr: 0x5AC, symBinAddr: 0x597C, symSize: 0x8 }
+  - { offsetInCU: 0xB00, offset: 0x78B4B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13testToDataURLySSs5Int64VFZTo', symObjAddr: 0x60C, symBinAddr: 0x59DC, symSize: 0x74 }
+  - { offsetInCU: 0xB8B, offset: 0x78BD6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZTo', symObjAddr: 0x814, symBinAddr: 0x5BE4, symSize: 0xA0 }
+  - { offsetInCU: 0xBDC, offset: 0x78C27, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZTo', symObjAddr: 0xB1C, symBinAddr: 0x5EEC, symSize: 0x98 }
+  - { offsetInCU: 0xC2D, offset: 0x78C78, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZTo', symObjAddr: 0xE70, symBinAddr: 0x6240, symSize: 0x98 }
+  - { offsetInCU: 0xC89, offset: 0x78CD4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZTo', symObjAddr: 0x1298, symBinAddr: 0x6668, symSize: 0xD8 }
+  - { offsetInCU: 0xCD1, offset: 0x78D1C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC32getPixelsPerInchForCurrentDeviceSSyFZTo', symObjAddr: 0x1374, symBinAddr: 0x6744, symSize: 0x34 }
+  - { offsetInCU: 0xD31, offset: 0x78D7C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCACycfcTo', symObjAddr: 0x13F8, symBinAddr: 0x67C8, symSize: 0x3C }
+  - { offsetInCU: 0xD82, offset: 0x78DCD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC19getBytesFromUIImageySo13NSMutableDataCSo0G0CFZTf4nd_n', symObjAddr: 0x1468, symBinAddr: 0x6838, symSize: 0x2AC }
+  - { offsetInCU: 0xFB6, offset: 0x79001, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13createPatternys5Int64VAF_So7UIImageCSStFZTf4nnnd_n', symObjAddr: 0x1714, symBinAddr: 0x6AE4, symSize: 0x264 }
+  - { offsetInCU: 0x11B0, offset: 0x791FB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC25loadImageAssetWithContextySbs5Int64V_So7UIImageCtFZTf4nnd_n', symObjAddr: 0x1978, symBinAddr: 0x6D48, symSize: 0xEC }
+  - { offsetInCU: 0x12AD, offset: 0x792F8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dyys5Int64V_So7UIImageCS2ftFZTf4nnnnd_n', symObjAddr: 0x1A64, symBinAddr: 0x6E34, symSize: 0x1B4 }
+  - { offsetInCU: 0x1422, offset: 0x7946D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dy2dw2dhys5Int64V_So7UIImageCS4ftFZTf4nnnnnnd_n', symObjAddr: 0x1C18, symBinAddr: 0x6FE8, symSize: 0x1CC }
+  - { offsetInCU: 0x15B7, offset: 0x79602, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2sx2sy2sw2sh2dx2dy2dw2dhys5Int64V_So7UIImageCS8ftFZTf4nnnnnnnnnnd_n', symObjAddr: 0x1DE4, symBinAddr: 0x71B4, symSize: 0x1E0 }
+  - { offsetInCU: 0x17A3, offset: 0x797EE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZTf4nnnd_n', symObjAddr: 0x1FC4, symBinAddr: 0x7394, symSize: 0x1B4 }
+  - { offsetInCU: 0x186D, offset: 0x798B8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZTf4nnnnd_n', symObjAddr: 0x231C, symBinAddr: 0x76EC, symSize: 0x1D4 }
+  - { offsetInCU: 0x194E, offset: 0x79999, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC32getPixelsPerInchForCurrentDeviceSSyFZTf4d_n', symObjAddr: 0x24F0, symBinAddr: 0x78C0, symSize: 0x114 }
+  - { offsetInCU: 0x19F9, offset: 0x79A44, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgACIeyByy_SSSgADIeggg_TR', symObjAddr: 0x8B4, symBinAddr: 0x5C84, symSize: 0x78 }
+  - { offsetInCU: 0x1A11, offset: 0x79A5C, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgSo6NSDataCSgIeyByy_SSSgAFIeggg_TR', symObjAddr: 0xBB4, symBinAddr: 0x5F84, symSize: 0x54 }
+  - { offsetInCU: 0x1A7E, offset: 0x79AC9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCfETo', symObjAddr: 0x1464, symBinAddr: 0x6834, symSize: 0x4 }
+  - { offsetInCU: 0x1B09, offset: 0x79B54, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCMa', symObjAddr: 0x2604, symBinAddr: 0x79D4, symSize: 0x20 }
+  - { offsetInCU: 0x1B1D, offset: 0x79B68, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgACIeyByy_SSSgADIeggg_TRTA', symObjAddr: 0x2648, symBinAddr: 0x7A18, symSize: 0x8 }
+  - { offsetInCU: 0x1B3C, offset: 0x79B87, size: 0x8, addend: 0x0, symName: '_$sSo7NSErrorCSg10ObjectiveC8ObjCBoolVIeyByy_ACSbIeggy_TRTA', symObjAddr: 0x2650, symBinAddr: 0x7A20, symSize: 0x18 }
+  - { offsetInCU: 0x1B65, offset: 0x79BB0, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgSo6NSDataCSgIeyByy_SSSgAFIeggg_TRTA', symObjAddr: 0x2668, symBinAddr: 0x7A38, symSize: 0x8 }
+  - { offsetInCU: 0x1B79, offset: 0x79BC4, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCMa', symObjAddr: 0x2670, symBinAddr: 0x7A40, symSize: 0x3C }
+  - { offsetInCU: 0x1B8D, offset: 0x79BD8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZyyYbcfU_TA', symObjAddr: 0x26F0, symBinAddr: 0x7AC0, symSize: 0x34 }
+  - { offsetInCU: 0x1BA1, offset: 0x79BEC, size: 0x8, addend: 0x0, symName: _block_copy_helper, symObjAddr: 0x2724, symBinAddr: 0x7AF4, symSize: 0x10 }
+  - { offsetInCU: 0x1BB5, offset: 0x79C00, size: 0x8, addend: 0x0, symName: _block_destroy_helper, symObjAddr: 0x2734, symBinAddr: 0x7B04, symSize: 0x8 }
+  - { offsetInCU: 0x1BC9, offset: 0x79C14, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZyyYbcfU_yyYbcfU0_TA', symObjAddr: 0x2760, symBinAddr: 0x7B30, symSize: 0x40 }
+  - { offsetInCU: 0x1BFD, offset: 0x79C48, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZyyYbcfU_yyYbcfU0_TA', symObjAddr: 0x27E4, symBinAddr: 0x7BB4, symSize: 0x40 }
+  - { offsetInCU: 0x1C3B, offset: 0x79C86, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZyyYbcfU_yyYbcfU_TA', symObjAddr: 0x2824, symBinAddr: 0x7BF4, symSize: 0x28 }
+  - { offsetInCU: 0x1C6F, offset: 0x79CBA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZyyYbcfU_yyYbcfU_TA', symObjAddr: 0x28A4, symBinAddr: 0x7C74, symSize: 0x3C }
+  - { offsetInCU: 0x1CA3, offset: 0x79CEE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZyyYbcfU_yyYbcfU0_TA', symObjAddr: 0x290C, symBinAddr: 0x7CDC, symSize: 0x30 }
+  - { offsetInCU: 0x1CDF, offset: 0x79D2A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZyyYbcfU_TA', symObjAddr: 0x2978, symBinAddr: 0x7D48, symSize: 0x10 }
+  - { offsetInCU: 0x1CF3, offset: 0x79D3E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZyyYbcfU_yyYbcfU_TA', symObjAddr: 0x2988, symBinAddr: 0x7D58, symSize: 0x40 }
+  - { offsetInCU: 0x21C0, offset: 0x7A20B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC19getBytesFromUIImageySo13NSMutableDataCSo0G0CFZ', symObjAddr: 0x0, symBinAddr: 0x53D0, symSize: 0x4 }
+  - { offsetInCU: 0x21DB, offset: 0x7A226, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x3C, symBinAddr: 0x540C, symSize: 0x4 }
+  - { offsetInCU: 0x21F6, offset: 0x7A241, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC25loadImageAssetWithContextySbs5Int64V_So7UIImageCtFZ', symObjAddr: 0xB0, symBinAddr: 0x5480, symSize: 0x4 }
+  - { offsetInCU: 0x2217, offset: 0x7A262, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dyys5Int64V_So7UIImageCS2ftFZ', symObjAddr: 0xF8, symBinAddr: 0x54C8, symSize: 0x4 }
+  - { offsetInCU: 0x2232, offset: 0x7A27D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dy2dw2dhys5Int64V_So7UIImageCS4ftFZ', symObjAddr: 0x14C, symBinAddr: 0x551C, symSize: 0x4 }
+  - { offsetInCU: 0x224D, offset: 0x7A298, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2sx2sy2sw2sh2dx2dy2dw2dhys5Int64V_So7UIImageCS8ftFZ', symObjAddr: 0x1B8, symBinAddr: 0x5588, symSize: 0x4 }
+  - { offsetInCU: 0x2268, offset: 0x7A2B3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23initWebGPUWithViewLayerys5Int64VAF_AFs6UInt32VAHtFZ', symObjAddr: 0x254, symBinAddr: 0x5624, symSize: 0x4 }
+  - { offsetInCU: 0x22F6, offset: 0x7A341, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC18initWebGPUWithViewys5Int64VAF_AFs6UInt32VAHtFZ', symObjAddr: 0x26C, symBinAddr: 0x563C, symSize: 0x4 }
+  - { offsetInCU: 0x2375, offset: 0x7A3C0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14initGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbtFZ', symObjAddr: 0x284, symBinAddr: 0x5654, symSize: 0x44 }
+  - { offsetInCU: 0x24B3, offset: 0x7A4FE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC20initSharedGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbAFtFZ', symObjAddr: 0x318, symBinAddr: 0x56E8, symSize: 0x4C }
+  - { offsetInCU: 0x25FC, offset: 0x7A647, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC24initGLWithWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbtFZ', symObjAddr: 0x3BC, symBinAddr: 0x578C, symSize: 0x48 }
+  - { offsetInCU: 0x2744, offset: 0x7A78F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC26initSharedGLWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbAFtFZ', symObjAddr: 0x45C, symBinAddr: 0x582C, symSize: 0x50 }
+  - { offsetInCU: 0x28A1, offset: 0x7A8EC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15resize2DContextyys5Int64V_S2ftFZ', symObjAddr: 0x50C, symBinAddr: 0x58DC, symSize: 0x4 }
+  - { offsetInCU: 0x2913, offset: 0x7A95E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14flush2DContextyys5Int64VFZ', symObjAddr: 0x518, symBinAddr: 0x58E8, symSize: 0x4 }
+  - { offsetInCU: 0x2956, offset: 0x7A9A1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC7flushGLySbs5Int64VFZ', symObjAddr: 0x524, symBinAddr: 0x58F4, symSize: 0x14 }
+  - { offsetInCU: 0x299B, offset: 0x7A9E6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9releaseGLyys5Int64VFZ', symObjAddr: 0x540, symBinAddr: 0x5910, symSize: 0x4 }
+  - { offsetInCU: 0x29DE, offset: 0x7AA29, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC12getGLPointerys5Int64VAFFZ', symObjAddr: 0x54C, symBinAddr: 0x591C, symSize: 0x4 }
+  - { offsetInCU: 0x2A21, offset: 0x7AA6C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC16releaseGLPointeryys5Int64VFZ', symObjAddr: 0x558, symBinAddr: 0x5928, symSize: 0x4 }
+  - { offsetInCU: 0x2A64, offset: 0x7AAAF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15create2DContextys5Int64VAF_s5Int32VAHSbSfA2HSfAHtFZ', symObjAddr: 0x564, symBinAddr: 0x5934, symSize: 0x8 }
+  - { offsetInCU: 0x2B4B, offset: 0x7AB96, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23updateGLSurfaceWithViewyys5Int64V_s5Int32VAhFtFZ', symObjAddr: 0x590, symBinAddr: 0x5960, symSize: 0x4 }
+  - { offsetInCU: 0x2BCA, offset: 0x7AC15, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC6test2Dyys5Int64VFZ', symObjAddr: 0x5A8, symBinAddr: 0x5978, symSize: 0x4 }
+  - { offsetInCU: 0x2C0D, offset: 0x7AC58, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13testToDataURLySSs5Int64VFZ', symObjAddr: 0x5B4, symBinAddr: 0x5984, symSize: 0x58 }
+  - { offsetInCU: 0x2CCE, offset: 0x7AD19, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZ', symObjAddr: 0x680, symBinAddr: 0x5A50, symSize: 0x4 }
+  - { offsetInCU: 0x2CE2, offset: 0x7AD2D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZyyYbcfU_', symObjAddr: 0x684, symBinAddr: 0x5A54, symSize: 0x190 }
+  - { offsetInCU: 0x2D82, offset: 0x7ADCD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZ', symObjAddr: 0x92C, symBinAddr: 0x5CFC, symSize: 0x2C }
+  - { offsetInCU: 0x2D96, offset: 0x7ADE1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZyyYbcfU_', symObjAddr: 0x958, symBinAddr: 0x5D28, symSize: 0x1C4 }
+  - { offsetInCU: 0x2E80, offset: 0x7AECB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZ', symObjAddr: 0xC08, symBinAddr: 0x5FD8, symSize: 0x2C }
+  - { offsetInCU: 0x2E94, offset: 0x7AEDF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZyyYbcfU_', symObjAddr: 0xC34, symBinAddr: 0x6004, symSize: 0x23C }
+  - { offsetInCU: 0x2F48, offset: 0x7AF93, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZ', symObjAddr: 0xF08, symBinAddr: 0x62D8, symSize: 0x4 }
+  - { offsetInCU: 0x2F5C, offset: 0x7AFA7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZyyYbcfU_', symObjAddr: 0xF0C, symBinAddr: 0x62DC, symSize: 0x38C }
+  - { offsetInCU: 0x31F3, offset: 0x7B23E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC32getPixelsPerInchForCurrentDeviceSSyFZ', symObjAddr: 0x1370, symBinAddr: 0x6740, symSize: 0x4 }
+  - { offsetInCU: 0x320E, offset: 0x7B259, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCACycfC', symObjAddr: 0x13A8, symBinAddr: 0x6778, symSize: 0x20 }
+  - { offsetInCU: 0x3222, offset: 0x7B26D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCACycfc', symObjAddr: 0x13C8, symBinAddr: 0x6798, symSize: 0x30 }
+  - { offsetInCU: 0x3258, offset: 0x7B2A3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCfD', symObjAddr: 0x1434, symBinAddr: 0x6804, symSize: 0x30 }
+  - { offsetInCU: 0x4F, offset: 0x7B4DB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19shared_context_view33_508084857CA7D194CA72FEB80DD78002LLSo7GLKViewCvpZ', symObjAddr: 0x55B0, symBinAddr: 0x114FD50, symSize: 0x0 }
+  - { offsetInCU: 0x69, offset: 0x7B4F5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15_shared_context33_508084857CA7D194CA72FEB80DD78002LLs5Int64VvpZ', symObjAddr: 0x55B8, symBinAddr: 0x114FD58, symSize: 0x0 }
+  - { offsetInCU: 0x83, offset: 0x7B50F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5storeSo19NSMutableDictionaryCvpZ', symObjAddr: 0x55C0, symBinAddr: 0x114FD60, symSize: 0x0 }
+  - { offsetInCU: 0x9D, offset: 0x7B529, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5views33_508084857CA7D194CA72FEB80DD78002LLSo10NSMapTableCySo8NSStringCACGvpZ', symObjAddr: 0x55C8, symBinAddr: 0x114FD68, symSize: 0x0 }
+  - { offsetInCU: 0xAB, offset: 0x7B537, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19shared_context_view33_508084857CA7D194CA72FEB80DD78002LL_WZ', symObjAddr: 0x0, symBinAddr: 0x7E80, symSize: 0x40 }
+  - { offsetInCU: 0xF0, offset: 0x7B57C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5store_WZ', symObjAddr: 0x40, symBinAddr: 0x7EC0, symSize: 0x30 }
+  - { offsetInCU: 0x135, offset: 0x7B5C1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5views33_508084857CA7D194CA72FEB80DD78002LL_WZ', symObjAddr: 0xA8, symBinAddr: 0x7F28, symSize: 0x40 }
+  - { offsetInCU: 0x187, offset: 0x7B613, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC3ptrSvSgvgTo', symObjAddr: 0x194, symBinAddr: 0x8014, symSize: 0x10 }
+  - { offsetInCU: 0x1A7, offset: 0x7B633, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC3ptrSvSgvgTo', symObjAddr: 0x194, symBinAddr: 0x8014, symSize: 0x10 }
+  - { offsetInCU: 0x1DD, offset: 0x7B669, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC3ptrSvSgvsTo', symObjAddr: 0x1A4, symBinAddr: 0x8024, symSize: 0x10 }
+  - { offsetInCU: 0x1FD, offset: 0x7B689, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC3ptrSvSgvsTo', symObjAddr: 0x1A4, symBinAddr: 0x8024, symSize: 0x10 }
+  - { offsetInCU: 0x236, offset: 0x7B6C2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6mtlPtrSvSgvgTo', symObjAddr: 0x1B4, symBinAddr: 0x8034, symSize: 0x10 }
+  - { offsetInCU: 0x256, offset: 0x7B6E2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6mtlPtrSvSgvgTo', symObjAddr: 0x1B4, symBinAddr: 0x8034, symSize: 0x10 }
+  - { offsetInCU: 0x28C, offset: 0x7B718, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6mtlPtrSvSgvsTo', symObjAddr: 0x1C4, symBinAddr: 0x8044, symSize: 0x10 }
+  - { offsetInCU: 0x2AC, offset: 0x7B738, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6mtlPtrSvSgvsTo', symObjAddr: 0x1C4, symBinAddr: 0x8044, symSize: 0x10 }
+  - { offsetInCU: 0x2E5, offset: 0x7B771, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvgTo', symObjAddr: 0x29C, symBinAddr: 0x811C, symSize: 0x44 }
+  - { offsetInCU: 0x322, offset: 0x7B7AE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvsTo', symObjAddr: 0x324, symBinAddr: 0x81A4, symSize: 0x30 }
+  - { offsetInCU: 0x3B1, offset: 0x7B83D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8nativeGLs5Int64VvgTo', symObjAddr: 0x578, symBinAddr: 0x83F8, symSize: 0x44 }
+  - { offsetInCU: 0x409, offset: 0x7B895, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8nativeGLs5Int64VvsTo', symObjAddr: 0x600, symBinAddr: 0x8480, symSize: 0x48 }
+  - { offsetInCU: 0x464, offset: 0x7B8F0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13nativeContexts5Int64VvgTo', symObjAddr: 0x648, symBinAddr: 0x84C8, symSize: 0x44 }
+  - { offsetInCU: 0x4BC, offset: 0x7B948, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13nativeContexts5Int64VvsTo', symObjAddr: 0x6D0, symBinAddr: 0x8550, symSize: 0x48 }
+  - { offsetInCU: 0x517, offset: 0x7B9A3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15native2DContexts5Int64VvgTo', symObjAddr: 0x718, symBinAddr: 0x8598, symSize: 0x10 }
+  - { offsetInCU: 0x537, offset: 0x7B9C3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15native2DContexts5Int64VvgTo', symObjAddr: 0x718, symBinAddr: 0x8598, symSize: 0x10 }
+  - { offsetInCU: 0x56D, offset: 0x7B9F9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15native2DContexts5Int64VvsTo', symObjAddr: 0x728, symBinAddr: 0x85A8, symSize: 0x10 }
+  - { offsetInCU: 0x58D, offset: 0x7BA19, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15native2DContexts5Int64VvsTo', symObjAddr: 0x728, symBinAddr: 0x85A8, symSize: 0x10 }
+  - { offsetInCU: 0x5C6, offset: 0x7BA52, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7mtlViewSo7MTKViewCvgTo', symObjAddr: 0x738, symBinAddr: 0x85B8, symSize: 0x10 }
+  - { offsetInCU: 0x5E6, offset: 0x7BA72, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7mtlViewSo7MTKViewCvgTo', symObjAddr: 0x738, symBinAddr: 0x85B8, symSize: 0x10 }
+  - { offsetInCU: 0x61E, offset: 0x7BAAA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7mtlViewSo7MTKViewCvsTo', symObjAddr: 0x748, symBinAddr: 0x85C8, symSize: 0x34 }
+  - { offsetInCU: 0x677, offset: 0x7BB03, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7glkViewAA0A7GLKViewCvgTo', symObjAddr: 0x77C, symBinAddr: 0x85FC, symSize: 0x10 }
+  - { offsetInCU: 0x697, offset: 0x7BB23, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7glkViewAA0A7GLKViewCvgTo', symObjAddr: 0x77C, symBinAddr: 0x85FC, symSize: 0x10 }
+  - { offsetInCU: 0x6CF, offset: 0x7BB5B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7glkViewAA0A7GLKViewCvsTo', symObjAddr: 0x78C, symBinAddr: 0x860C, symSize: 0x34 }
+  - { offsetInCU: 0x728, offset: 0x7BBB4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC4is2DSbvgTo', symObjAddr: 0x7C0, symBinAddr: 0x8640, symSize: 0x10 }
+  - { offsetInCU: 0x748, offset: 0x7BBD4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC4is2DSbvgTo', symObjAddr: 0x7C0, symBinAddr: 0x8640, symSize: 0x10 }
+  - { offsetInCU: 0x77E, offset: 0x7BC0A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC4is2DSbvsTo', symObjAddr: 0x7D0, symBinAddr: 0x8650, symSize: 0x10 }
+  - { offsetInCU: 0x79E, offset: 0x7BC2A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC4is2DSbvsTo', symObjAddr: 0x7D0, symBinAddr: 0x8650, symSize: 0x10 }
+  - { offsetInCU: 0x7D7, offset: 0x7BC63, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7isMetalSbvgTo', symObjAddr: 0x7E0, symBinAddr: 0x8660, symSize: 0x10 }
+  - { offsetInCU: 0x7F7, offset: 0x7BC83, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7isMetalSbvgTo', symObjAddr: 0x7E0, symBinAddr: 0x8660, symSize: 0x10 }
+  - { offsetInCU: 0x82D, offset: 0x7BCB9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7isMetalSbvsTo', symObjAddr: 0x7F0, symBinAddr: 0x8670, symSize: 0x10 }
+  - { offsetInCU: 0x84D, offset: 0x7BCD9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7isMetalSbvsTo', symObjAddr: 0x7F0, symBinAddr: 0x8670, symSize: 0x10 }
+  - { offsetInCU: 0x870, offset: 0x7BCFC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18drawingBufferWidthSivgTo', symObjAddr: 0x800, symBinAddr: 0x8680, symSize: 0x34 }
+  - { offsetInCU: 0x8A2, offset: 0x7BD2E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19drawingBufferHeightSivgTo', symObjAddr: 0x904, symBinAddr: 0x8784, symSize: 0x34 }
+  - { offsetInCU: 0x8EA, offset: 0x7BD76, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5widthSfvgTo', symObjAddr: 0xA08, symBinAddr: 0x8888, symSize: 0x20 }
+  - { offsetInCU: 0x952, offset: 0x7BDDE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6heightSfvgTo', symObjAddr: 0xA4C, symBinAddr: 0x88CC, symSize: 0x20 }
+  - { offsetInCU: 0x9F1, offset: 0x7BE7D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11initContextyySS_S4bs5Int32VS5btFTo', symObjAddr: 0xAB4, symBinAddr: 0x8934, symSize: 0xC4 }
+  - { offsetInCU: 0xAB4, offset: 0x7BF40, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17initWebGPUContextyys5Int64VFTo', symObjAddr: 0xD10, symBinAddr: 0x8B90, symSize: 0x30 }
+  - { offsetInCU: 0xB64, offset: 0x7BFF0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC015initContextWithE10AttributesyySS_S4bs5Int32VS5btFTo', symObjAddr: 0x15B0, symBinAddr: 0x9430, symSize: 0xC4 }
+  - { offsetInCU: 0xBCE, offset: 0x7C05A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15create2DContextys5Int64VSb_S3bs5Int32VS5bAHtFTo', symObjAddr: 0x18CC, symBinAddr: 0x974C, symSize: 0xB0 }
+  - { offsetInCU: 0xC0B, offset: 0x7C097, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11forceLayoutyy12CoreGraphics7CGFloatV_AGtFTo', symObjAddr: 0x1A3C, symBinAddr: 0x98BC, symSize: 0xB8 }
+  - { offsetInCU: 0xC83, offset: 0x7C10F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8snapshotySo7UIImageCSgSbFTo', symObjAddr: 0x1BD8, symBinAddr: 0x9A58, symSize: 0x3C }
+  - { offsetInCU: 0xCB6, offset: 0x7C142, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8rendererAA9NSCRenderCSgvgTo', symObjAddr: 0x1C14, symBinAddr: 0x9A94, symSize: 0x10 }
+  - { offsetInCU: 0xCD6, offset: 0x7C162, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8rendererAA9NSCRenderCSgvgTo', symObjAddr: 0x1C14, symBinAddr: 0x9A94, symSize: 0x10 }
+  - { offsetInCU: 0xD10, offset: 0x7C19C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8rendererAA9NSCRenderCSgvsTo', symObjAddr: 0x1C24, symBinAddr: 0x9AA4, symSize: 0x34 }
+  - { offsetInCU: 0xD6B, offset: 0x7C1F7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6renderSbyFTo', symObjAddr: 0x1CA0, symBinAddr: 0x9B20, symSize: 0x48 }
+  - { offsetInCU: 0xE05, offset: 0x7C291, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13context2DTestyys5Int64VFTo', symObjAddr: 0x1D34, symBinAddr: 0x9BB4, symSize: 0x64 }
+  - { offsetInCU: 0xECA, offset: 0x7C356, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC22context2DTestToDataURLySSs5Int64VFTo', symObjAddr: 0x1DF0, symBinAddr: 0x9C70, symSize: 0x94 }
+  - { offsetInCU: 0xF57, offset: 0x7C3E3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC23enterBackgroundListeneryycSgvsTo', symObjAddr: 0x1EC4, symBinAddr: 0x9D44, symSize: 0x6C }
+  - { offsetInCU: 0xFB9, offset: 0x7C445, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC20becomeActiveListeneryycSgvsTo', symObjAddr: 0x1FD4, symBinAddr: 0x9E54, symSize: 0x6C }
+  - { offsetInCU: 0x1016, offset: 0x7C4A2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvgTo', symObjAddr: 0x2040, symBinAddr: 0x9EC0, symSize: 0xB0 }
+  - { offsetInCU: 0x1068, offset: 0x7C4F4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvsTo', symObjAddr: 0x21C0, symBinAddr: 0xA040, symSize: 0x94 }
+  - { offsetInCU: 0x10FA, offset: 0x7C586, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5coderACSgSo7NSCoderC_tcfcTo', symObjAddr: 0x2EAC, symBinAddr: 0xAD2C, symSize: 0x28 }
+  - { offsetInCU: 0x114F, offset: 0x7C5DB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5frameACSo6CGRectV_tcfcTo', symObjAddr: 0x392C, symBinAddr: 0xB7AC, symSize: 0x20 }
+  - { offsetInCU: 0x1182, offset: 0x7C60E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvgTo', symObjAddr: 0x394C, symBinAddr: 0xB7CC, symSize: 0x10 }
+  - { offsetInCU: 0x11A2, offset: 0x7C62E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvgTo', symObjAddr: 0x394C, symBinAddr: 0xB7CC, symSize: 0x10 }
+  - { offsetInCU: 0x11DA, offset: 0x7C666, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvsTo', symObjAddr: 0x395C, symBinAddr: 0xB7DC, symSize: 0x34 }
+  - { offsetInCU: 0x1248, offset: 0x7C6D4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13readyListenerAA0cE0_pSgvgTo', symObjAddr: 0x3A10, symBinAddr: 0xB890, symSize: 0x20 }
+  - { offsetInCU: 0x12A2, offset: 0x7C72E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13readyListenerAA0cE0_pSgvsTo', symObjAddr: 0x3A30, symBinAddr: 0xB8B0, symSize: 0x34 }
+  - { offsetInCU: 0x1302, offset: 0x7C78E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11setListeneryyAA0cE0_pSgFTo', symObjAddr: 0x3A94, symBinAddr: 0xB914, symSize: 0x34 }
+  - { offsetInCU: 0x1446, offset: 0x7C8D2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC14layoutSubviewsyyFTo', symObjAddr: 0x3DE0, symBinAddr: 0xBC60, symSize: 0x28 }
+  - { offsetInCU: 0x1479, offset: 0x7C905, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCfDTo', symObjAddr: 0x410C, symBinAddr: 0xBF8C, symSize: 0x24 }
+  - { offsetInCU: 0x14B4, offset: 0x7C940, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC21getBoundingClientRectyySo6UIViewC_SvtFZTo', symObjAddr: 0x41F8, symBinAddr: 0xC078, symSize: 0x34 }
+  - { offsetInCU: 0x14E7, offset: 0x7C973, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC14shared_context33_508084857CA7D194CA72FEB80DD78002LLs5Int64VvgZTf4d_n', symObjAddr: 0x4B8C, symBinAddr: 0xCA0C, symSize: 0x298 }
+  - { offsetInCU: 0x1664, offset: 0x7CAF0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC21getBoundingClientRectyySo6UIViewC_SvtFZTf4nnd_n', symObjAddr: 0x4EE8, symBinAddr: 0xCD68, symSize: 0xA0 }
+  - { offsetInCU: 0x18E0, offset: 0x7CD6C, size: 0x8, addend: 0x0, symName: '_$sIeg_IeyB_TR', symObjAddr: 0x1E98, symBinAddr: 0x9D18, symSize: 0x2C }
+  - { offsetInCU: 0x18F8, offset: 0x7CD84, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_So8NSStringCABIeyByy_TR', symObjAddr: 0x2148, symBinAddr: 0x9FC8, symSize: 0x78 }
+  - { offsetInCU: 0x1910, offset: 0x7CD9C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvpACTK', symObjAddr: 0x22B0, symBinAddr: 0xA130, symSize: 0x94 }
+  - { offsetInCU: 0x1948, offset: 0x7CDD4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvpACTk', symObjAddr: 0x2344, symBinAddr: 0xA1C4, symSize: 0xB8 }
+  - { offsetInCU: 0x198A, offset: 0x7CE16, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCytIegnnr_SSABIeggg_TR', symObjAddr: 0x23FC, symBinAddr: 0xA27C, symSize: 0x6C }
+  - { offsetInCU: 0x1A3A, offset: 0x7CEC6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCfETo', symObjAddr: 0x4130, symBinAddr: 0xBFB0, symSize: 0xC4 }
+  - { offsetInCU: 0x1A6A, offset: 0x7CEF6, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_SgWOy', symObjAddr: 0x422C, symBinAddr: 0xC0AC, symSize: 0x10 }
+  - { offsetInCU: 0x1A7E, offset: 0x7CF0A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCMa', symObjAddr: 0x423C, symBinAddr: 0xC0BC, symSize: 0x20 }
+  - { offsetInCU: 0x1A92, offset: 0x7CF1E, size: 0x8, addend: 0x0, symName: '_$ss29getContiguousArrayStorageType3fors01_bcD0CyxGmxm_tlFSo18NSLayoutConstraintC_Tgm5', symObjAddr: 0x425C, symBinAddr: 0xC0DC, symSize: 0x64 }
+  - { offsetInCU: 0x1C99, offset: 0x7D125, size: 0x8, addend: 0x0, symName: ___swift_instantiateConcreteTypeFromMangledName, symObjAddr: 0x4E24, symBinAddr: 0xCCA4, symSize: 0x40 }
+  - { offsetInCU: 0x1CAD, offset: 0x7D139, size: 0x8, addend: 0x0, symName: '_$sypSgWOh', symObjAddr: 0x4E64, symBinAddr: 0xCCE4, symSize: 0x40 }
+  - { offsetInCU: 0x1CC1, offset: 0x7D14D, size: 0x8, addend: 0x0, symName: ___swift_project_boxed_opaque_existential_0, symObjAddr: 0x4EA4, symBinAddr: 0xCD24, symSize: 0x24 }
+  - { offsetInCU: 0x1CD5, offset: 0x7D161, size: 0x8, addend: 0x0, symName: ___swift_destroy_boxed_opaque_existential_0, symObjAddr: 0x4EC8, symBinAddr: 0xCD48, symSize: 0x20 }
+  - { offsetInCU: 0x1CF4, offset: 0x7D180, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSo19UIGestureRecognizerCIeyByy_SSADIeggg_TRTA', symObjAddr: 0x53B4, symBinAddr: 0xD234, symSize: 0x48 }
+  - { offsetInCU: 0x1D1D, offset: 0x7D1A9, size: 0x8, addend: 0x0, symName: _block_copy_helper, symObjAddr: 0x53FC, symBinAddr: 0xD27C, symSize: 0x10 }
+  - { offsetInCU: 0x1D31, offset: 0x7D1BD, size: 0x8, addend: 0x0, symName: _block_destroy_helper, symObjAddr: 0x540C, symBinAddr: 0xD28C, symSize: 0x8 }
+  - { offsetInCU: 0x1D45, offset: 0x7D1D1, size: 0x8, addend: 0x0, symName: '_$sIeg_SgWOe', symObjAddr: 0x5414, symBinAddr: 0xD294, symSize: 0x10 }
+  - { offsetInCU: 0x1D64, offset: 0x7D1F0, size: 0x8, addend: 0x0, symName: '_$sIeyB_Ieg_TRTA', symObjAddr: 0x5424, symBinAddr: 0xD2A4, symSize: 0xC }
+  - { offsetInCU: 0x1D8D, offset: 0x7D219, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCytIegnnr_SSABIeggg_TRTA', symObjAddr: 0x5454, symBinAddr: 0xD2D4, symSize: 0x8 }
+  - { offsetInCU: 0x1DAC, offset: 0x7D238, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_SSABytIegnnr_TRTA', symObjAddr: 0x545C, symBinAddr: 0xD2DC, symSize: 0x30 }
+  - { offsetInCU: 0x1DD5, offset: 0x7D261, size: 0x8, addend: 0x0, symName: '_$sypWOb', symObjAddr: 0x548C, symBinAddr: 0xD30C, symSize: 0x10 }
+  - { offsetInCU: 0x1DE9, offset: 0x7D275, size: 0x8, addend: 0x0, symName: '_$sypWOc', symObjAddr: 0x54D4, symBinAddr: 0xD354, symSize: 0x3C }
+  - { offsetInCU: 0x206E, offset: 0x7D4FA, size: 0x8, addend: 0x0, symName: '_$sSD17dictionaryLiteralSDyxq_Gx_q_td_tcfCSS_ypTgm5Tf4g_n', symObjAddr: 0x4A7C, symBinAddr: 0xC8FC, symSize: 0x110 }
+  - { offsetInCU: 0x251C, offset: 0x7D9A8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvg', symObjAddr: 0x2E0, symBinAddr: 0x8160, symSize: 0x44 }
+  - { offsetInCU: 0x254F, offset: 0x7D9DB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvs', symObjAddr: 0x354, symBinAddr: 0x81D4, symSize: 0xEC }
+  - { offsetInCU: 0x259B, offset: 0x7DA27, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvM', symObjAddr: 0x440, symBinAddr: 0x82C0, symSize: 0x58 }
+  - { offsetInCU: 0x25C0, offset: 0x7DA4C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvM.resume.0', symObjAddr: 0x498, symBinAddr: 0x8318, symSize: 0xE0 }
+  - { offsetInCU: 0x2601, offset: 0x7DA8D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8nativeGLs5Int64Vvg', symObjAddr: 0x5BC, symBinAddr: 0x843C, symSize: 0x44 }
+  - { offsetInCU: 0x2659, offset: 0x7DAE5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13nativeContexts5Int64Vvg', symObjAddr: 0x68C, symBinAddr: 0x850C, symSize: 0x44 }
+  - { offsetInCU: 0x27C7, offset: 0x7DC53, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18drawingBufferWidthSivg', symObjAddr: 0x834, symBinAddr: 0x86B4, symSize: 0xD0 }
+  - { offsetInCU: 0x28EC, offset: 0x7DD78, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19drawingBufferHeightSivg', symObjAddr: 0x938, symBinAddr: 0x87B8, symSize: 0xD0 }
+  - { offsetInCU: 0x2A32, offset: 0x7DEBE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5widthSfvg', symObjAddr: 0xA28, symBinAddr: 0x88A8, symSize: 0x24 }
+  - { offsetInCU: 0x2A7A, offset: 0x7DF06, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6heightSfvg', symObjAddr: 0xA6C, symBinAddr: 0x88EC, symSize: 0x24 }
+  - { offsetInCU: 0x2AAE, offset: 0x7DF3A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11initContextyySS_S4bs5Int32VS5btF', symObjAddr: 0xA90, symBinAddr: 0x8910, symSize: 0x24 }
+  - { offsetInCU: 0x2C3C, offset: 0x7E0C8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17initWebGPUContextyys5Int64VF', symObjAddr: 0xB78, symBinAddr: 0x89F8, symSize: 0x198 }
+  - { offsetInCU: 0x302F, offset: 0x7E4BB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC015initContextWithE10AttributesyySS_S4bs5Int32VS5btF', symObjAddr: 0xD40, symBinAddr: 0x8BC0, symSize: 0x870 }
+  - { offsetInCU: 0x3832, offset: 0x7ECBE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15create2DContextys5Int64VSb_S3bs5Int32VS5bAHtF', symObjAddr: 0x1674, symBinAddr: 0x94F4, symSize: 0x258 }
+  - { offsetInCU: 0x3C64, offset: 0x7F0F0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11forceLayoutyy12CoreGraphics7CGFloatV_AGtF', symObjAddr: 0x197C, symBinAddr: 0x97FC, symSize: 0xC0 }
+  - { offsetInCU: 0x3CF5, offset: 0x7F181, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8snapshotySo7UIImageCSgSbF', symObjAddr: 0x1AF4, symBinAddr: 0x9974, symSize: 0xE4 }
+  - { offsetInCU: 0x3E50, offset: 0x7F2DC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6renderSbyF', symObjAddr: 0x1C58, symBinAddr: 0x9AD8, symSize: 0x48 }
+  - { offsetInCU: 0x3ED6, offset: 0x7F362, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13context2DTestyys5Int64VF', symObjAddr: 0x1CE8, symBinAddr: 0x9B68, symSize: 0x4C }
+  - { offsetInCU: 0x3FF7, offset: 0x7F483, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC22context2DTestToDataURLySSs5Int64VF', symObjAddr: 0x1D98, symBinAddr: 0x9C18, symSize: 0x58 }
+  - { offsetInCU: 0x40ED, offset: 0x7F579, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvg', symObjAddr: 0x20F0, symBinAddr: 0x9F70, symSize: 0x58 }
+  - { offsetInCU: 0x4139, offset: 0x7F5C5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvs', symObjAddr: 0x2254, symBinAddr: 0xA0D4, symSize: 0x5C }
+  - { offsetInCU: 0x4162, offset: 0x7F5EE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvM', symObjAddr: 0x2468, symBinAddr: 0xA2E8, symSize: 0x44 }
+  - { offsetInCU: 0x4188, offset: 0x7F614, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvM.resume.0', symObjAddr: 0x24AC, symBinAddr: 0xA32C, symSize: 0x4 }
+  - { offsetInCU: 0x424A, offset: 0x7F6D6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5coderACSgSo7NSCoderC_tcfc', symObjAddr: 0x24B0, symBinAddr: 0xA330, symSize: 0x9FC }
+  - { offsetInCU: 0x446D, offset: 0x7F8F9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5frameACSo6CGRectV_tcfC', symObjAddr: 0x2ED4, symBinAddr: 0xAD54, symSize: 0x50 }
+  - { offsetInCU: 0x4496, offset: 0x7F922, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5frameACSo6CGRectV_tcfc', symObjAddr: 0x2F24, symBinAddr: 0xADA4, symSize: 0xA08 }
+  - { offsetInCU: 0x46DA, offset: 0x7FB66, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvW', symObjAddr: 0x3990, symBinAddr: 0xB810, symSize: 0x80 }
+  - { offsetInCU: 0x47D0, offset: 0x7FC5C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11setListeneryyAA0cE0_pSgF', symObjAddr: 0x3A64, symBinAddr: 0xB8E4, symSize: 0x30 }
+  - { offsetInCU: 0x486E, offset: 0x7FCFA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6resize33_508084857CA7D194CA72FEB80DD78002LLyyF', symObjAddr: 0x3AC8, symBinAddr: 0xB948, symSize: 0x144 }
+  - { offsetInCU: 0x4A6F, offset: 0x7FEFB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC14layoutSubviewsyyF', symObjAddr: 0x3C0C, symBinAddr: 0xBA8C, symSize: 0x1D4 }
+  - { offsetInCU: 0x4CEC, offset: 0x80178, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCfD', symObjAddr: 0x3E08, symBinAddr: 0xBC88, symSize: 0x304 }
+  - { offsetInCU: 0x4D7C, offset: 0x80208, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC21getBoundingClientRectyySo6UIViewC_SvtFZ', symObjAddr: 0x41F4, symBinAddr: 0xC074, symSize: 0x4 }
+  - { offsetInCU: 0x4DA4, offset: 0x80230, size: 0x8, addend: 0x0, symName: '_$ss22__RawDictionaryStorageC4findys10_HashTableV6BucketV6bucket_Sb5foundtxSHRzlFSS_Tg5', symObjAddr: 0x42C0, symBinAddr: 0xC140, symSize: 0x64 }
+  - { offsetInCU: 0x4DFE, offset: 0x8028A, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV7_insert2at3key5valueys10_HashTableV6BucketV_xnq_ntFSS_ypTg5', symObjAddr: 0x4324, symBinAddr: 0xC1A4, symSize: 0x6C }
+  - { offsetInCU: 0x4E7E, offset: 0x8030A, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV12mutatingFind_8isUniques10_HashTableV6BucketV6bucket_Sb5foundtx_SbtFSS_ypTg5', symObjAddr: 0x4390, symBinAddr: 0xC210, symSize: 0xD8 }
+  - { offsetInCU: 0x4EBB, offset: 0x80347, size: 0x8, addend: 0x0, symName: '_$ss22__RawDictionaryStorageC4find_9hashValues10_HashTableV6BucketV6bucket_Sb5foundtx_SitSHRzlFSS_Tg5', symObjAddr: 0x4468, symBinAddr: 0xC2E8, symSize: 0xE0 }
+  - { offsetInCU: 0x4F36, offset: 0x803C2, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV4copyyyFSS_ypTg5', symObjAddr: 0x4548, symBinAddr: 0xC3C8, symSize: 0x1F4 }
+  - { offsetInCU: 0x4FF2, offset: 0x8047E, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV20_copyOrMoveAndResize8capacity12moveElementsySi_SbtFSS_ypTg5', symObjAddr: 0x473C, symBinAddr: 0xC5BC, symSize: 0x340 }
+  - { offsetInCU: 0x27, offset: 0x806E6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative7GLUtilsCfD', symObjAddr: 0x0, symBinAddr: 0xD3F4, symSize: 0x10 }
+  - { offsetInCU: 0x62, offset: 0x80721, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative7GLUtilsCMa', symObjAddr: 0x10, symBinAddr: 0xD404, symSize: 0x20 }
+  - { offsetInCU: 0x1AF, offset: 0x8086E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative7GLUtilsCfD', symObjAddr: 0x0, symBinAddr: 0xD3F4, symSize: 0x10 }
+  - { offsetInCU: 0x65, offset: 0x808FD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8mPrograms6UInt32VvgTo', symObjAddr: 0x0, symBinAddr: 0xD424, symSize: 0x10 }
+  - { offsetInCU: 0x85, offset: 0x8091D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8mPrograms6UInt32VvgTo', symObjAddr: 0x0, symBinAddr: 0xD424, symSize: 0x10 }
+  - { offsetInCU: 0xBB, offset: 0x80953, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8mPrograms6UInt32VvsTo', symObjAddr: 0x10, symBinAddr: 0xD434, symSize: 0x10 }
+  - { offsetInCU: 0xDB, offset: 0x80973, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8mPrograms6UInt32VvsTo', symObjAddr: 0x10, symBinAddr: 0xD434, symSize: 0x10 }
+  - { offsetInCU: 0x114, offset: 0x809AC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3rbos6UInt32VvgTo', symObjAddr: 0x20, symBinAddr: 0xD444, symSize: 0x44 }
+  - { offsetInCU: 0x16C, offset: 0x80A04, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3rbos6UInt32VvsTo', symObjAddr: 0x64, symBinAddr: 0xD488, symSize: 0x48 }
+  - { offsetInCU: 0x1C7, offset: 0x80A5F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3fbos6UInt32VvgTo', symObjAddr: 0xAC, symBinAddr: 0xD4D0, symSize: 0x44 }
+  - { offsetInCU: 0x21F, offset: 0x80AB7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3fbos6UInt32VvsTo', symObjAddr: 0xF0, symBinAddr: 0xD514, symSize: 0x48 }
+  - { offsetInCU: 0x27A, offset: 0x80B12, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC5widthSivgTo', symObjAddr: 0x138, symBinAddr: 0xD55C, symSize: 0x10 }
+  - { offsetInCU: 0x29A, offset: 0x80B32, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC5widthSivgTo', symObjAddr: 0x138, symBinAddr: 0xD55C, symSize: 0x10 }
+  - { offsetInCU: 0x2D0, offset: 0x80B68, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC5widthSivsTo', symObjAddr: 0x148, symBinAddr: 0xD56C, symSize: 0x10 }
+  - { offsetInCU: 0x2F0, offset: 0x80B88, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC5widthSivsTo', symObjAddr: 0x148, symBinAddr: 0xD56C, symSize: 0x10 }
+  - { offsetInCU: 0x329, offset: 0x80BC1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC6heightSivgTo', symObjAddr: 0x158, symBinAddr: 0xD57C, symSize: 0x10 }
+  - { offsetInCU: 0x349, offset: 0x80BE1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC6heightSivgTo', symObjAddr: 0x158, symBinAddr: 0xD57C, symSize: 0x10 }
+  - { offsetInCU: 0x37F, offset: 0x80C17, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC6heightSivsTo', symObjAddr: 0x168, symBinAddr: 0xD58C, symSize: 0x10 }
+  - { offsetInCU: 0x39F, offset: 0x80C37, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC6heightSivsTo', symObjAddr: 0x168, symBinAddr: 0xD58C, symSize: 0x10 }
+  - { offsetInCU: 0x3D8, offset: 0x80C70, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC2abs6UInt32VvgTo', symObjAddr: 0x178, symBinAddr: 0xD59C, symSize: 0x44 }
+  - { offsetInCU: 0x430, offset: 0x80CC8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC2abs6UInt32VvsTo', symObjAddr: 0x1BC, symBinAddr: 0xD5E0, symSize: 0x48 }
+  - { offsetInCU: 0x48B, offset: 0x80D23, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3poss5Int32VvgTo', symObjAddr: 0x204, symBinAddr: 0xD628, symSize: 0x10 }
+  - { offsetInCU: 0x4AB, offset: 0x80D43, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3poss5Int32VvgTo', symObjAddr: 0x204, symBinAddr: 0xD628, symSize: 0x10 }
+  - { offsetInCU: 0x4E1, offset: 0x80D79, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3poss5Int32VvsTo', symObjAddr: 0x214, symBinAddr: 0xD638, symSize: 0x10 }
+  - { offsetInCU: 0x501, offset: 0x80D99, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3poss5Int32VvsTo', symObjAddr: 0x214, symBinAddr: 0xD638, symSize: 0x10 }
+  - { offsetInCU: 0x53A, offset: 0x80DD2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10samplerPoss5Int32VvgTo', symObjAddr: 0x224, symBinAddr: 0xD648, symSize: 0x10 }
+  - { offsetInCU: 0x55A, offset: 0x80DF2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10samplerPoss5Int32VvgTo', symObjAddr: 0x224, symBinAddr: 0xD648, symSize: 0x10 }
+  - { offsetInCU: 0x590, offset: 0x80E28, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10samplerPoss5Int32VvsTo', symObjAddr: 0x234, symBinAddr: 0xD658, symSize: 0x10 }
+  - { offsetInCU: 0x5B0, offset: 0x80E48, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10samplerPoss5Int32VvsTo', symObjAddr: 0x234, symBinAddr: 0xD658, symSize: 0x10 }
+  - { offsetInCU: 0x5E9, offset: 0x80E81, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9vextexBufSaySfGvgTo', symObjAddr: 0x244, symBinAddr: 0xD668, symSize: 0x48 }
+  - { offsetInCU: 0x63F, offset: 0x80ED7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9vextexBufSaySfGvsTo', symObjAddr: 0x28C, symBinAddr: 0xD6B0, symSize: 0x40 }
+  - { offsetInCU: 0x682, offset: 0x80F1A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13SIZE_OF_FLOATSivgZTo', symObjAddr: 0x2CC, symBinAddr: 0xD6F0, symSize: 0x8 }
+  - { offsetInCU: 0x69E, offset: 0x80F36, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13VERTEX_SHADERSSvgZTo', symObjAddr: 0x2D4, symBinAddr: 0xD6F8, symSize: 0x2C }
+  - { offsetInCU: 0x6D0, offset: 0x80F68, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7surfaceSo9IOSurfaceCSgvgTo', symObjAddr: 0x300, symBinAddr: 0xD724, symSize: 0x10 }
+  - { offsetInCU: 0x6F0, offset: 0x80F88, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7surfaceSo9IOSurfaceCSgvgTo', symObjAddr: 0x300, symBinAddr: 0xD724, symSize: 0x10 }
+  - { offsetInCU: 0x728, offset: 0x80FC0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7surfaceSo9IOSurfaceCSgvsTo', symObjAddr: 0x310, symBinAddr: 0xD734, symSize: 0x34 }
+  - { offsetInCU: 0x781, offset: 0x81019, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8pixelBufs9UnmanagedVySo11CVBufferRefaGSgvgTo', symObjAddr: 0x418, symBinAddr: 0xD83C, symSize: 0x10 }
+  - { offsetInCU: 0x7A1, offset: 0x81039, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8pixelBufs9UnmanagedVySo11CVBufferRefaGSgvgTo', symObjAddr: 0x418, symBinAddr: 0xD83C, symSize: 0x10 }
+  - { offsetInCU: 0x7D7, offset: 0x8106F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8pixelBufs9UnmanagedVySo11CVBufferRefaGSgvsTo', symObjAddr: 0x428, symBinAddr: 0xD84C, symSize: 0x10 }
+  - { offsetInCU: 0x7F7, offset: 0x8108F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8pixelBufs9UnmanagedVySo11CVBufferRefaGSgvsTo', symObjAddr: 0x428, symBinAddr: 0xD84C, symSize: 0x10 }
+  - { offsetInCU: 0x846, offset: 0x810DE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCACycfcTo', symObjAddr: 0x5A4, symBinAddr: 0xD988, symSize: 0x20 }
+  - { offsetInCU: 0x878, offset: 0x81110, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7destroyyyFTo', symObjAddr: 0x708, symBinAddr: 0xDAEC, symSize: 0x28 }
+  - { offsetInCU: 0x8D0, offset: 0x81168, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10texImage2Dyys5Int32V_A4fA9NSCCanvasCAHSbtFTo', symObjAddr: 0x744, symBinAddr: 0xDB28, symSize: 0x88 }
+  - { offsetInCU: 0x934, offset: 0x811CC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9drawFrame6buffer5width6height14internalFormat6format10flipYWebGLySo11CVBufferRefa_S2is5Int32VANSbtFTo', symObjAddr: 0x7CC, symBinAddr: 0xDBB0, symSize: 0x7C }
+  - { offsetInCU: 0x9D6, offset: 0x8126E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13createSurfaceyyFTo', symObjAddr: 0xBF4, symBinAddr: 0xDFD8, symSize: 0x28 }
+  - { offsetInCU: 0xAC0, offset: 0x81358, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCMa', symObjAddr: 0x584, symBinAddr: 0xD968, symSize: 0x20 }
+  - { offsetInCU: 0xB34, offset: 0x813CC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCfETo', symObjAddr: 0xC4C, symBinAddr: 0xE030, symSize: 0x58 }
+  - { offsetInCU: 0x123B, offset: 0x81AD3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCACycfC', symObjAddr: 0x438, symBinAddr: 0xD85C, symSize: 0x20 }
+  - { offsetInCU: 0x1255, offset: 0x81AED, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCACycfc', symObjAddr: 0x458, symBinAddr: 0xD87C, symSize: 0xEC }
+  - { offsetInCU: 0x128D, offset: 0x81B25, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7destroyyyF', symObjAddr: 0x5C4, symBinAddr: 0xD9A8, symSize: 0x144 }
+  - { offsetInCU: 0x1448, offset: 0x81CE0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10texImage2Dyys5Int32V_A4fA9NSCCanvasCAHSbtF', symObjAddr: 0x730, symBinAddr: 0xDB14, symSize: 0x14 }
+  - { offsetInCU: 0x14F9, offset: 0x81D91, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13createSurfaceyyF', symObjAddr: 0x848, symBinAddr: 0xDC2C, symSize: 0x3AC }
+  - { offsetInCU: 0x1869, offset: 0x82101, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCfD', symObjAddr: 0xC1C, symBinAddr: 0xE000, symSize: 0x30 }
+  - { offsetInCU: 0x1954, offset: 0x821EC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10texImage2Dyys5Int32V_A4fA9NSCCanvasCAHSbtFTf4ddnndnndn_n', symObjAddr: 0xCA4, symBinAddr: 0xE088, symSize: 0x65C }
+  - { offsetInCU: 0x2152, offset: 0x829EA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9drawFrame6buffer5width6height14internalFormat6format10flipYWebGLySo11CVBufferRefa_S2is5Int32VANSbtFTf4nnnnndn_n', symObjAddr: 0x1344, symBinAddr: 0xE728, symSize: 0x6C8 }
+  - { offsetInCU: 0x10C, offset: 0x833AA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC6target6actionAEypSg_10ObjectiveC8SelectorVSgtcfcTo', symObjAddr: 0xED4, symBinAddr: 0xFC9C, symSize: 0x68 }
+  - { offsetInCU: 0x19C, offset: 0x8343A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerCfETo', symObjAddr: 0xF48, symBinAddr: 0xFD10, symSize: 0x10 }
+  - { offsetInCU: 0x1CB, offset: 0x83469, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC6handleyySo19UIGestureRecognizerCFTo', symObjAddr: 0xF58, symBinAddr: 0xFD20, symSize: 0x4 }
+  - { offsetInCU: 0x368, offset: 0x83606, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerCACycfcTo', symObjAddr: 0x16DC, symBinAddr: 0x104A4, symSize: 0x2C }
+  - { offsetInCU: 0x5D4, offset: 0x83872, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerCfETo', symObjAddr: 0x1744, symBinAddr: 0x1050C, symSize: 0x68 }
+  - { offsetInCU: 0x603, offset: 0x838A1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerCMa', symObjAddr: 0x17AC, symBinAddr: 0x10574, symSize: 0x20 }
+  - { offsetInCU: 0x617, offset: 0x838B5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerCMa', symObjAddr: 0x17CC, symBinAddr: 0x10594, symSize: 0x20 }
+  - { offsetInCU: 0x62B, offset: 0x838C9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwCP', symObjAddr: 0x17EC, symBinAddr: 0x105B4, symSize: 0x30 }
+  - { offsetInCU: 0x63F, offset: 0x838DD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwxx', symObjAddr: 0x181C, symBinAddr: 0x105E4, symSize: 0x8 }
+  - { offsetInCU: 0x653, offset: 0x838F1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwcp', symObjAddr: 0x1824, symBinAddr: 0x105EC, symSize: 0x3C }
+  - { offsetInCU: 0x667, offset: 0x83905, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwca', symObjAddr: 0x1860, symBinAddr: 0x10628, symSize: 0x50 }
+  - { offsetInCU: 0x67B, offset: 0x83919, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwta', symObjAddr: 0x18BC, symBinAddr: 0x10678, symSize: 0x40 }
+  - { offsetInCU: 0x68F, offset: 0x8392D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwet', symObjAddr: 0x18FC, symBinAddr: 0x106B8, symSize: 0x48 }
+  - { offsetInCU: 0x6A3, offset: 0x83941, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwst', symObjAddr: 0x1944, symBinAddr: 0x10700, symSize: 0x40 }
+  - { offsetInCU: 0x6B7, offset: 0x83955, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVMa', symObjAddr: 0x1984, symBinAddr: 0x10740, symSize: 0x10 }
+  - { offsetInCU: 0x6CB, offset: 0x83969, size: 0x8, addend: 0x0, symName: '_$sypSgWOc', symObjAddr: 0x1994, symBinAddr: 0x10750, symSize: 0x48 }
+  - { offsetInCU: 0x6DF, offset: 0x8397D, size: 0x8, addend: 0x0, symName: '_$sSo7UITouchCSo8NSObjectCSH10ObjectiveCWl', symObjAddr: 0x1AA0, symBinAddr: 0x10798, symSize: 0x58 }
+  - { offsetInCU: 0x6F3, offset: 0x83991, size: 0x8, addend: 0x0, symName: '_$sSh8IteratorV8_VariantOyx__GSHRzlWOe', symObjAddr: 0x1AF8, symBinAddr: 0x107F0, symSize: 0x8 }
+  - { offsetInCU: 0x761, offset: 0x839FF, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_SgWOe', symObjAddr: 0x1DE4, symBinAddr: 0x10ADC, symSize: 0x10 }
+  - { offsetInCU: 0xCBB, offset: 0x83F59, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC12touchesBegan_4withyShySo7UITouchCG_So7UIEventCtF', symObjAddr: 0x0, symBinAddr: 0xEDF0, symSize: 0x540 }
+  - { offsetInCU: 0xF57, offset: 0x841F5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC12touchesMoved_4withyShySo7UITouchCG_So7UIEventCtF', symObjAddr: 0x54C, symBinAddr: 0xF33C, symSize: 0xE0 }
+  - { offsetInCU: 0xFD6, offset: 0x84274, size: 0x8, addend: 0x0, symName: '_$sSa6remove2atxSi_tF12CanvasNative15NSCTouchHandlerC7PointerV_Tg5', symObjAddr: 0x6F0, symBinAddr: 0xF4CC, symSize: 0x9C }
+  - { offsetInCU: 0x1069, offset: 0x84307, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC6target6actionAEypSg_10ObjectiveC8SelectorVSgtcfc', symObjAddr: 0xDCC, symBinAddr: 0xFB94, symSize: 0x108 }
+  - { offsetInCU: 0x11B3, offset: 0x84451, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC6onMove33_044DDF836BDB3B89B481C6F58BB6EF6BLLyySo19UIGestureRecognizerC_ShySo7UITouchCGSgtF', symObjAddr: 0x12D0, symBinAddr: 0x10098, symSize: 0x40C }
+  - { offsetInCU: 0x18C9, offset: 0x84B67, size: 0x8, addend: 0x0, symName: '_$ss12_ArrayBufferV20_consumeAndCreateNewAByxGyF12CanvasNative15NSCTouchHandlerC7PointerV_Tg5', symObjAddr: 0x1B00, symBinAddr: 0x107F8, symSize: 0x14 }
+  - { offsetInCU: 0x1968, offset: 0x84C06, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC6canvasAcA9NSCCanvasC_tcfcTf4gn_n', symObjAddr: 0x1B14, symBinAddr: 0x1080C, symSize: 0x1DC }
+  - { offsetInCU: 0x27, offset: 0x84DE3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC14FAILED_TO_LOADSSvgZTo', symObjAddr: 0x0, symBinAddr: 0x10AEC, symSize: 0x2C }
+  - { offsetInCU: 0x4B, offset: 0x84E07, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queueSo012OS_dispatch_E0CvpZ', symObjAddr: 0x2D8, symBinAddr: 0x1150078, symSize: 0x0 }
+  - { offsetInCU: 0x65, offset: 0x84E21, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC14FAILED_TO_LOADSSvgZTo', symObjAddr: 0x0, symBinAddr: 0x10AEC, symSize: 0x2C }
+  - { offsetInCU: 0x98, offset: 0x84E54, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queueSo012OS_dispatch_E0CvgZTo', symObjAddr: 0x178, symBinAddr: 0x10C64, symSize: 0x40 }
+  - { offsetInCU: 0x104, offset: 0x84EC0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCACycfcTo', symObjAddr: 0x228, symBinAddr: 0x10D14, symSize: 0x3C }
+  - { offsetInCU: 0x156, offset: 0x84F12, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queue_WZ', symObjAddr: 0x2C, symBinAddr: 0x10B18, symSize: 0x10C }
+  - { offsetInCU: 0x181, offset: 0x84F3D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCMa', symObjAddr: 0x208, symBinAddr: 0x10CF4, symSize: 0x20 }
+  - { offsetInCU: 0x195, offset: 0x84F51, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCfETo', symObjAddr: 0x294, symBinAddr: 0x10D80, symSize: 0x4 }
+  - { offsetInCU: 0x1C0, offset: 0x84F7C, size: 0x8, addend: 0x0, symName: '_$sSo17OS_dispatch_queueCMa', symObjAddr: 0x298, symBinAddr: 0x10D84, symSize: 0x3C }
+  - { offsetInCU: 0x348, offset: 0x85104, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queueSo012OS_dispatch_E0CvgZ', symObjAddr: 0x138, symBinAddr: 0x10C24, symSize: 0x40 }
+  - { offsetInCU: 0x388, offset: 0x85144, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCACycfC', symObjAddr: 0x1B8, symBinAddr: 0x10CA4, symSize: 0x20 }
+  - { offsetInCU: 0x39C, offset: 0x85158, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCACycfc', symObjAddr: 0x1D8, symBinAddr: 0x10CC4, symSize: 0x30 }
+  - { offsetInCU: 0x3D8, offset: 0x85194, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCfD', symObjAddr: 0x264, symBinAddr: 0x10D50, symSize: 0x30 }
+  - { offsetInCU: 0x2B, offset: 0x851E2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC18createTextureCacheSo017CVOpenGLESTextureF3RefaSgyFZ', symObjAddr: 0x0, symBinAddr: 0x10DC0, symSize: 0xA4 }
+  - { offsetInCU: 0x66, offset: 0x8521D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC18createTextureCacheSo017CVOpenGLESTextureF3RefaSgyFZTo', symObjAddr: 0xA4, symBinAddr: 0x10E64, symSize: 0xA4 }
+  - { offsetInCU: 0xF9, offset: 0x852B0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11createImageySo11CVBufferRefaSgSo022CVOpenGLESTextureCacheG0a_AFSo012CFDictionaryG0aSgs6UInt32Vs5Int32VA2p2NSitFZTo', symObjAddr: 0x1D8, symBinAddr: 0x10F98, symSize: 0x110 }
+  - { offsetInCU: 0x1A2, offset: 0x85359, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11setupRenderAA9NSCRenderCyFZTo', symObjAddr: 0x30C, symBinAddr: 0x110CC, symSize: 0x28 }
+  - { offsetInCU: 0x222, offset: 0x853D9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC9drawFrameyySo8AVPlayerC_So0F15ItemVideoOutputCSo6CGSizeVAA9NSCRenderCs5Int32VANSbtFZTo', symObjAddr: 0x338, symBinAddr: 0x110F8, symSize: 0xA0 }
+  - { offsetInCU: 0x29B, offset: 0x85452, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11writeToFileyySo6NSDataC_SStKFZTo', symObjAddr: 0x4D0, symBinAddr: 0x11290, symSize: 0x15C }
+  - { offsetInCU: 0x330, offset: 0x854E7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCACycfcTo', symObjAddr: 0x67C, symBinAddr: 0x1143C, symSize: 0x3C }
+  - { offsetInCU: 0x381, offset: 0x85538, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC9drawFrameyySo8AVPlayerC_So0F15ItemVideoOutputCSo6CGSizeVAA9NSCRenderCs5Int32VANSbtFZTf4nnnnnndd_n', symObjAddr: 0x6E8, symBinAddr: 0x114A8, symSize: 0x160 }
+  - { offsetInCU: 0x4DF, offset: 0x85696, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC7getFile33_F00B23A4165DD6ABFCD23C8811C7DF43LLyS2SKFZTf4nd_g', symObjAddr: 0x848, symBinAddr: 0x11608, symSize: 0x2E4 }
+  - { offsetInCU: 0x5AE, offset: 0x85765, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCMa', symObjAddr: 0xB2C, symBinAddr: 0x118EC, symSize: 0x20 }
+  - { offsetInCU: 0x5C2, offset: 0x85779, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOAEs5ErrorAAWl', symObjAddr: 0xB4C, symBinAddr: 0x1190C, symSize: 0x44 }
+  - { offsetInCU: 0x5D6, offset: 0x8578D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwCP', symObjAddr: 0xB90, symBinAddr: 0x11950, symSize: 0x2C }
+  - { offsetInCU: 0x5EA, offset: 0x857A1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwxx', symObjAddr: 0xBBC, symBinAddr: 0x1197C, symSize: 0x8 }
+  - { offsetInCU: 0x5FE, offset: 0x857B5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwca', symObjAddr: 0xBC4, symBinAddr: 0x11984, symSize: 0x40 }
+  - { offsetInCU: 0x612, offset: 0x857C9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwta', symObjAddr: 0xC10, symBinAddr: 0x119C4, symSize: 0x30 }
+  - { offsetInCU: 0x626, offset: 0x857DD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwet', symObjAddr: 0xC40, symBinAddr: 0x119F4, symSize: 0x48 }
+  - { offsetInCU: 0x63A, offset: 0x857F1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwst', symObjAddr: 0xC88, symBinAddr: 0x11A3C, symSize: 0x3C }
+  - { offsetInCU: 0x64E, offset: 0x85805, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwug', symObjAddr: 0xCC4, symBinAddr: 0x11A78, symSize: 0x8 }
+  - { offsetInCU: 0x662, offset: 0x85819, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwup', symObjAddr: 0xCCC, symBinAddr: 0x11A80, symSize: 0x4 }
+  - { offsetInCU: 0x676, offset: 0x8582D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwui', symObjAddr: 0xCD0, symBinAddr: 0x11A84, symSize: 0x4 }
+  - { offsetInCU: 0x68A, offset: 0x85841, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOMa', symObjAddr: 0xCD4, symBinAddr: 0x11A88, symSize: 0x10 }
+  - { offsetInCU: 0x712, offset: 0x858C9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP7_domainSSvgTW', symObjAddr: 0x3D8, symBinAddr: 0x11198, symSize: 0x4 }
+  - { offsetInCU: 0x72E, offset: 0x858E5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP5_codeSivgTW', symObjAddr: 0x3DC, symBinAddr: 0x1119C, symSize: 0x4 }
+  - { offsetInCU: 0x74A, offset: 0x85901, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP9_userInfoyXlSgvgTW', symObjAddr: 0x3E0, symBinAddr: 0x111A0, symSize: 0x4 }
+  - { offsetInCU: 0x766, offset: 0x8591D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP19_getEmbeddedNSErroryXlSgyFTW', symObjAddr: 0x3E4, symBinAddr: 0x111A4, symSize: 0x4 }
+  - { offsetInCU: 0xA14, offset: 0x85BCB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC18createTextureCacheSo017CVOpenGLESTextureF3RefaSgyFZ', symObjAddr: 0x0, symBinAddr: 0x10DC0, symSize: 0xA4 }
+  - { offsetInCU: 0xAAA, offset: 0x85C61, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11createImageySo11CVBufferRefaSgSo022CVOpenGLESTextureCacheG0a_AFSo012CFDictionaryG0aSgs6UInt32Vs5Int32VA2p2NSitFZ', symObjAddr: 0x148, symBinAddr: 0x10F08, symSize: 0x90 }
+  - { offsetInCU: 0xC31, offset: 0x85DE8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11setupRenderAA9NSCRenderCyFZ', symObjAddr: 0x2E8, symBinAddr: 0x110A8, symSize: 0x24 }
+  - { offsetInCU: 0xC7B, offset: 0x85E32, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC9drawFrameyySo8AVPlayerC_So0F15ItemVideoOutputCSo6CGSizeVAA9NSCRenderCs5Int32VANSbtFZ', symObjAddr: 0x334, symBinAddr: 0x110F4, symSize: 0x4 }
+  - { offsetInCU: 0xC9D, offset: 0x85E54, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11writeToFileyySo6NSDataC_SStKFZ', symObjAddr: 0x3E8, symBinAddr: 0x111A8, symSize: 0xE8 }
+  - { offsetInCU: 0xD4D, offset: 0x85F04, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCACycfC', symObjAddr: 0x62C, symBinAddr: 0x113EC, symSize: 0x20 }
+  - { offsetInCU: 0xD61, offset: 0x85F18, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCACycfc', symObjAddr: 0x64C, symBinAddr: 0x1140C, symSize: 0x30 }
+  - { offsetInCU: 0xD97, offset: 0x85F4E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCfD', symObjAddr: 0x6B8, symBinAddr: 0x11478, symSize: 0x30 }
+  - { offsetInCU: 0x27, offset: 0x86067, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x0, symBinAddr: 0x11A9C, symSize: 0x4 }
+  - { offsetInCU: 0x71, offset: 0x860B1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZTo', symObjAddr: 0x4, symBinAddr: 0x11AA0, symSize: 0x70 }
+  - { offsetInCU: 0xF6, offset: 0x86136, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS2ftFZTo', symObjAddr: 0x78, symBinAddr: 0x11B14, symSize: 0x50 }
+  - { offsetInCU: 0x191, offset: 0x861D1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS4ftFZTo', symObjAddr: 0xCC, symBinAddr: 0x11B68, symSize: 0x68 }
+  - { offsetInCU: 0x254, offset: 0x86294, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS8ftFZTo', symObjAddr: 0x138, symBinAddr: 0x11BD4, symSize: 0x98 }
+  - { offsetInCU: 0x323, offset: 0x86363, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCACycfcTo', symObjAddr: 0x220, symBinAddr: 0x11CBC, symSize: 0x3C }
+  - { offsetInCU: 0x375, offset: 0x863B5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCMa', symObjAddr: 0x28C, symBinAddr: 0x11D28, symSize: 0x20 }
+  - { offsetInCU: 0x4E5, offset: 0x86525, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x0, symBinAddr: 0x11A9C, symSize: 0x4 }
+  - { offsetInCU: 0x51D, offset: 0x8655D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x0, symBinAddr: 0x11A9C, symSize: 0x4 }
+  - { offsetInCU: 0x588, offset: 0x865C8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS2ftFZ', symObjAddr: 0x74, symBinAddr: 0x11B10, symSize: 0x4 }
+  - { offsetInCU: 0x5C8, offset: 0x86608, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS2ftFZ', symObjAddr: 0x74, symBinAddr: 0x11B10, symSize: 0x4 }
+  - { offsetInCU: 0x62A, offset: 0x8666A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS4ftFZ', symObjAddr: 0xC8, symBinAddr: 0x11B64, symSize: 0x4 }
+  - { offsetInCU: 0x67C, offset: 0x866BC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS4ftFZ', symObjAddr: 0xC8, symBinAddr: 0x11B64, symSize: 0x4 }
+  - { offsetInCU: 0x6F1, offset: 0x86731, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS8ftFZ', symObjAddr: 0x134, symBinAddr: 0x11BD0, symSize: 0x4 }
+  - { offsetInCU: 0x767, offset: 0x867A7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS8ftFZ', symObjAddr: 0x134, symBinAddr: 0x11BD0, symSize: 0x4 }
+  - { offsetInCU: 0x805, offset: 0x86845, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCACycfC', symObjAddr: 0x1D0, symBinAddr: 0x11C6C, symSize: 0x20 }
+  - { offsetInCU: 0x819, offset: 0x86859, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCACycfc', symObjAddr: 0x1F0, symBinAddr: 0x11C8C, symSize: 0x30 }
+  - { offsetInCU: 0x84F, offset: 0x8688F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCfD', symObjAddr: 0x25C, symBinAddr: 0x11CF8, symSize: 0x30 }
+  - { offsetInCU: 0x27, offset: 0x868D9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC10texImage2Dyys5Int64V_s5Int32VA4HSpys5UInt8VGSuSo6CGSizeVSbtFZ', symObjAddr: 0x0, symBinAddr: 0x11D48, symSize: 0x14 }
+  - { offsetInCU: 0xA9, offset: 0x8695B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC10texImage2Dyys5Int64V_s5Int32VA4HSpys5UInt8VGSuSo6CGSizeVSbtFZTo', symObjAddr: 0x14, symBinAddr: 0x11D5C, symSize: 0x38 }
+  - { offsetInCU: 0x1A2, offset: 0x86A54, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC13texSubImage2Dyys5Int64V_s5Int32VA5HSpys5UInt8VGSuSo6CGSizeVSbtFZTo', symObjAddr: 0x68, symBinAddr: 0x11DB0, symSize: 0x40 }
+  - { offsetInCU: 0x284, offset: 0x86B36, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCACycfcTo', symObjAddr: 0x118, symBinAddr: 0x11E60, symSize: 0x3C }
+  - { offsetInCU: 0x2D6, offset: 0x86B88, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCMa', symObjAddr: 0xF8, symBinAddr: 0x11E40, symSize: 0x20 }
+  - { offsetInCU: 0x480, offset: 0x86D32, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC10texImage2Dyys5Int64V_s5Int32VA4HSpys5UInt8VGSuSo6CGSizeVSbtFZ', symObjAddr: 0x0, symBinAddr: 0x11D48, symSize: 0x14 }
+  - { offsetInCU: 0x5C4, offset: 0x86E76, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC13texSubImage2Dyys5Int64V_s5Int32VA5HSpys5UInt8VGSuSo6CGSizeVSbtFZ', symObjAddr: 0x4C, symBinAddr: 0x11D94, symSize: 0x1C }
+  - { offsetInCU: 0x6FA, offset: 0x86FAC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCACycfC', symObjAddr: 0xA8, symBinAddr: 0x11DF0, symSize: 0x20 }
+  - { offsetInCU: 0x70E, offset: 0x86FC0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCACycfc', symObjAddr: 0xC8, symBinAddr: 0x11E10, symSize: 0x30 }
+  - { offsetInCU: 0x744, offset: 0x86FF6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCfD', symObjAddr: 0x154, symBinAddr: 0x11E9C, symSize: 0x30 }
+  - { offsetInCU: 0x61, offset: 0x8707A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7isDirtySbvgTo', symObjAddr: 0x4, symBinAddr: 0x11ED0, symSize: 0x10 }
+  - { offsetInCU: 0x81, offset: 0x8709A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7isDirtySbvgTo', symObjAddr: 0x4, symBinAddr: 0x11ED0, symSize: 0x10 }
+  - { offsetInCU: 0xB7, offset: 0x870D0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7isDirtySbvsTo', symObjAddr: 0x14, symBinAddr: 0x11EE0, symSize: 0x10 }
+  - { offsetInCU: 0xD7, offset: 0x870F0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7isDirtySbvsTo', symObjAddr: 0x14, symBinAddr: 0x11EE0, symSize: 0x10 }
+  - { offsetInCU: 0x110, offset: 0x87129, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC6canvasAA9NSCCanvasCSgvgTo', symObjAddr: 0x24, symBinAddr: 0x11EF0, symSize: 0x48 }
+  - { offsetInCU: 0x168, offset: 0x87181, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC6canvasAA9NSCCanvasCSgvsTo', symObjAddr: 0xB4, symBinAddr: 0x11F80, symSize: 0x50 }
+  - { offsetInCU: 0x1C3, offset: 0x871DC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC3fbos6UInt32VvgTo', symObjAddr: 0x104, symBinAddr: 0x11FD0, symSize: 0x10 }
+  - { offsetInCU: 0x1E3, offset: 0x871FC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC3fbos6UInt32VvgTo', symObjAddr: 0x104, symBinAddr: 0x11FD0, symSize: 0x10 }
+  - { offsetInCU: 0x219, offset: 0x87232, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC3fbos6UInt32VvsTo', symObjAddr: 0x114, symBinAddr: 0x11FE0, symSize: 0x10 }
+  - { offsetInCU: 0x239, offset: 0x87252, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC3fbos6UInt32VvsTo', symObjAddr: 0x114, symBinAddr: 0x11FE0, symSize: 0x10 }
+  - { offsetInCU: 0x272, offset: 0x8728B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCACycfcTo', symObjAddr: 0x1B0, symBinAddr: 0x1207C, symSize: 0x78 }
+  - { offsetInCU: 0x2C8, offset: 0x872E1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frameACSo6CGRectV_tcfcTo', symObjAddr: 0x2D4, symBinAddr: 0x121A0, symSize: 0xB0 }
+  - { offsetInCU: 0x32A, offset: 0x87343, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5coderACSgSo7NSCoderC_tcfcTo', symObjAddr: 0x43C, symBinAddr: 0x12308, symSize: 0x28 }
+  - { offsetInCU: 0x35C, offset: 0x87375, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC12bindDrawableyyFTo', symObjAddr: 0x4E0, symBinAddr: 0x12330, symSize: 0xA0 }
+  - { offsetInCU: 0x3DD, offset: 0x873F6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC14deleteDrawableyyFTo', symObjAddr: 0x5BC, symBinAddr: 0x123D0, symSize: 0x60 }
+  - { offsetInCU: 0x44D, offset: 0x87466, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7glkView_6drawInySo0C0C_So6CGRectVtFTo', symObjAddr: 0x620, symBinAddr: 0x12434, symSize: 0x4C }
+  - { offsetInCU: 0x4BF, offset: 0x874D8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frame7contextACSo6CGRectV_So11EAGLContextCtcfcTo', symObjAddr: 0x70C, symBinAddr: 0x12520, symSize: 0x34 }
+  - { offsetInCU: 0x533, offset: 0x8754C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCMa', symObjAddr: 0x190, symBinAddr: 0x1205C, symSize: 0x20 }
+  - { offsetInCU: 0x55D, offset: 0x87576, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCfETo', symObjAddr: 0x74C, symBinAddr: 0x12560, symSize: 0x10 }
+  - { offsetInCU: 0x65B, offset: 0x87674, size: 0x8, addend: 0x0, symName: '_$sSo7GLKViewC12CanvasNativeE16snapshotWithDatayy10Foundation0F0VFTo', symObjAddr: 0xA08, symBinAddr: 0x1281C, symSize: 0x74 }
+  - { offsetInCU: 0x699, offset: 0x876B2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC7isDirtySbvgTo', symObjAddr: 0xA7C, symBinAddr: 0x12890, symSize: 0x10 }
+  - { offsetInCU: 0x6B9, offset: 0x876D2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC7isDirtySbvgTo', symObjAddr: 0xA7C, symBinAddr: 0x12890, symSize: 0x10 }
+  - { offsetInCU: 0x6EF, offset: 0x87708, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC7isDirtySbvsTo', symObjAddr: 0xA8C, symBinAddr: 0x128A0, symSize: 0x10 }
+  - { offsetInCU: 0x70F, offset: 0x87728, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC7isDirtySbvsTo', symObjAddr: 0xA8C, symBinAddr: 0x128A0, symSize: 0x10 }
+  - { offsetInCU: 0x748, offset: 0x87761, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC8rendererAA9NSCCanvasCSgvgTo', symObjAddr: 0xA9C, symBinAddr: 0x128B0, symSize: 0x20 }
+  - { offsetInCU: 0x7A0, offset: 0x877B9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC8rendererAA9NSCCanvasCSgvsTo', symObjAddr: 0xABC, symBinAddr: 0x128D0, symSize: 0x14 }
+  - { offsetInCU: 0x7FB, offset: 0x87814, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvgTo', symObjAddr: 0xAD0, symBinAddr: 0x128E4, symSize: 0x44 }
+  - { offsetInCU: 0x853, offset: 0x8786C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvsTo', symObjAddr: 0xB58, symBinAddr: 0x1296C, symSize: 0x48 }
+  - { offsetInCU: 0x8E8, offset: 0x87901, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCACycfcTo', symObjAddr: 0xCBC, symBinAddr: 0x12AD0, symSize: 0x78 }
+  - { offsetInCU: 0x93E, offset: 0x87957, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5frameACSo6CGRectV_tcfcTo', symObjAddr: 0xE34, symBinAddr: 0x12C48, symSize: 0xB0 }
+  - { offsetInCU: 0x9A0, offset: 0x879B9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5coderACSgSo7NSCoderC_tcfcTo', symObjAddr: 0xF90, symBinAddr: 0x12DA4, symSize: 0x28 }
+  - { offsetInCU: 0x9D2, offset: 0x879EB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC11deviceScaleSfyFTo', symObjAddr: 0xFB8, symBinAddr: 0x12DCC, symSize: 0xB8 }
+  - { offsetInCU: 0xA53, offset: 0x87A6C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC4drawyySo6CGRectVFTo', symObjAddr: 0x1074, symBinAddr: 0x12E84, symSize: 0x28 }
+  - { offsetInCU: 0xAB1, offset: 0x87ACA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCfETo', symObjAddr: 0x10D8, symBinAddr: 0x12EE8, symSize: 0x10 }
+  - { offsetInCU: 0xC88, offset: 0x87CA1, size: 0x8, addend: 0x0, symName: '_$ss22_ContiguousArrayBufferV19_uninitializedCount15minimumCapacityAByxGSi_SitcfCs5UInt8V_Tgmq5', symObjAddr: 0x13D0, symBinAddr: 0x130E4, symSize: 0x64 }
+  - { offsetInCU: 0xCD9, offset: 0x87CF2, size: 0x8, addend: 0x0, symName: '_$s10Foundation4DataV15_RepresentationOWOy', symObjAddr: 0x15D8, symBinAddr: 0x132EC, symSize: 0x44 }
+  - { offsetInCU: 0xCED, offset: 0x87D06, size: 0x8, addend: 0x0, symName: '_$s10Foundation4DataV15_RepresentationOWOe', symObjAddr: 0x161C, symBinAddr: 0x13330, symSize: 0x44 }
+  - { offsetInCU: 0xD01, offset: 0x87D1A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCMa', symObjAddr: 0x1660, symBinAddr: 0x13374, symSize: 0x20 }
+  - { offsetInCU: 0xDDB, offset: 0x87DF4, size: 0x8, addend: 0x0, symName: '_$sSaySayxGqd__c7ElementQyd__RszSTRd__lufCs5UInt8V_10Foundation4DataVTgm5Tf4g_n', symObjAddr: 0x14B8, symBinAddr: 0x131CC, symSize: 0x110 }
+  - { offsetInCU: 0x1086, offset: 0x8809F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC6canvasAA9NSCCanvasCSgvg', symObjAddr: 0x6C, symBinAddr: 0x11F38, symSize: 0x48 }
+  - { offsetInCU: 0x1103, offset: 0x8811C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCACycfc', symObjAddr: 0x124, symBinAddr: 0x11FF0, symSize: 0x6C }
+  - { offsetInCU: 0x114A, offset: 0x88163, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frameACSo6CGRectV_tcfc', symObjAddr: 0x228, symBinAddr: 0x120F4, symSize: 0xAC }
+  - { offsetInCU: 0x11AE, offset: 0x881C7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5coderACSgSo7NSCoderC_tcfc', symObjAddr: 0x384, symBinAddr: 0x12250, symSize: 0xB8 }
+  - { offsetInCU: 0x1239, offset: 0x88252, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7glkView_6drawInySo0C0C_So6CGRectVtF', symObjAddr: 0x61C, symBinAddr: 0x12430, symSize: 0x4 }
+  - { offsetInCU: 0x125A, offset: 0x88273, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frame7contextACSo6CGRectV_So11EAGLContextCtcfC', symObjAddr: 0x66C, symBinAddr: 0x12480, symSize: 0x74 }
+  - { offsetInCU: 0x126E, offset: 0x88287, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frame7contextACSo6CGRectV_So11EAGLContextCtcfc', symObjAddr: 0x6E0, symBinAddr: 0x124F4, symSize: 0x2C }
+  - { offsetInCU: 0x1387, offset: 0x883A0, size: 0x8, addend: 0x0, symName: '_$sSo7GLKViewC12CanvasNativeE16snapshotWithDatayy10Foundation0F0VF', symObjAddr: 0x75C, symBinAddr: 0x12570, symSize: 0x2AC }
+  - { offsetInCU: 0x1731, offset: 0x8874A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvg', symObjAddr: 0xB14, symBinAddr: 0x12928, symSize: 0x44 }
+  - { offsetInCU: 0x1770, offset: 0x88789, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvs', symObjAddr: 0xBA0, symBinAddr: 0x129B4, symSize: 0x48 }
+  - { offsetInCU: 0x1795, offset: 0x887AE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvM', symObjAddr: 0xBE8, symBinAddr: 0x129FC, symSize: 0x44 }
+  - { offsetInCU: 0x17BA, offset: 0x887D3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvM.resume.0', symObjAddr: 0xC2C, symBinAddr: 0x12A40, symSize: 0x4 }
+  - { offsetInCU: 0x17E1, offset: 0x887FA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCACycfC', symObjAddr: 0xC30, symBinAddr: 0x12A44, symSize: 0x20 }
+  - { offsetInCU: 0x17F5, offset: 0x8880E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCACycfc', symObjAddr: 0xC50, symBinAddr: 0x12A64, symSize: 0x6C }
+  - { offsetInCU: 0x183C, offset: 0x88855, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5frameACSo6CGRectV_tcfc', symObjAddr: 0xD88, symBinAddr: 0x12B9C, symSize: 0xAC }
+  - { offsetInCU: 0x189B, offset: 0x888B4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5coderACSgSo7NSCoderC_tcfc', symObjAddr: 0xEE4, symBinAddr: 0x12CF8, symSize: 0xAC }
+  - { offsetInCU: 0x1940, offset: 0x88959, size: 0x8, addend: 0x0, symName: '_$ss12_ArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtF12CanvasNative15NSCTouchHandlerC7PointerV_Tg5', symObjAddr: 0x10E8, symBinAddr: 0x12EF8, symSize: 0x104 }
+  - { offsetInCU: 0x1A6F, offset: 0x88A88, size: 0x8, addend: 0x0, symName: '_$ss12_ArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtFs5UInt8V_Tg5', symObjAddr: 0x12E8, symBinAddr: 0x12FFC, symSize: 0xE8 }
+  - { offsetInCU: 0x1BB3, offset: 0x88BCC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7glkView_6drawInySo0C0C_So6CGRectVtFTf4ddn_n', symObjAddr: 0x1434, symBinAddr: 0x13148, symSize: 0x84 }
+  - { offsetInCU: 0x1CAC, offset: 0x88CC5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC4drawyySo6CGRectVFTf4dn_n', symObjAddr: 0x1680, symBinAddr: 0x13394, symSize: 0x360 }
+  - { offsetInCU: 0x2B, offset: 0x890DF, size: 0x8, addend: 0x0, symName: '_$sIegh_IeyBh_TR', symObjAddr: 0x0, symBinAddr: 0x138E0, symSize: 0x2C }
+  - { offsetInCU: 0x4F, offset: 0x89103, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC5queue33_7ED578B0ED4B2B6F6887A622A7B49AA3LLSo012OS_dispatch_E0CvpZ', symObjAddr: 0x958, symBinAddr: 0x11501C0, symSize: 0x0 }
+  - { offsetInCU: 0x5D, offset: 0x89111, size: 0x8, addend: 0x0, symName: '_$sIegh_IeyBh_TR', symObjAddr: 0x0, symBinAddr: 0x138E0, symSize: 0x2C }
+  - { offsetInCU: 0x75, offset: 0x89129, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC5queue33_7ED578B0ED4B2B6F6887A622A7B49AA3LL_WZ', symObjAddr: 0x2C, symBinAddr: 0x1390C, symSize: 0x10C }
+  - { offsetInCU: 0xBC, offset: 0x89170, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF4SyncySbs5Int64V_So7UIImageCtFZTo', symObjAddr: 0x13C, symBinAddr: 0x13A1C, symSize: 0x44 }
+  - { offsetInCU: 0x132, offset: 0x891E6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZTo', symObjAddr: 0x3AC, symBinAddr: 0x13C8C, symSize: 0x80 }
+  - { offsetInCU: 0x191, offset: 0x89245, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCACycfcTo', symObjAddr: 0x47C, symBinAddr: 0x13D5C, symSize: 0x3C }
+  - { offsetInCU: 0x1E2, offset: 0x89296, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZTf4nnnd_n', symObjAddr: 0x4EC, symBinAddr: 0x13DCC, symSize: 0x1DC }
+  - { offsetInCU: 0x269, offset: 0x8931D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCfETo', symObjAddr: 0x4E8, symBinAddr: 0x13DC8, symSize: 0x4 }
+  - { offsetInCU: 0x2A5, offset: 0x89359, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCMa', symObjAddr: 0x6C8, symBinAddr: 0x13FA8, symSize: 0x20 }
+  - { offsetInCU: 0x2C4, offset: 0x89378, size: 0x8, addend: 0x0, symName: '_$s10ObjectiveC8ObjCBoolVIeyBy_SbIegy_TRTA', symObjAddr: 0x70C, symBinAddr: 0x13FEC, symSize: 0x14 }
+  - { offsetInCU: 0x2ED, offset: 0x893A1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_TA', symObjAddr: 0x74C, symBinAddr: 0x1402C, symSize: 0xC }
+  - { offsetInCU: 0x301, offset: 0x893B5, size: 0x8, addend: 0x0, symName: _block_copy_helper, symObjAddr: 0x758, symBinAddr: 0x14038, symSize: 0x10 }
+  - { offsetInCU: 0x315, offset: 0x893C9, size: 0x8, addend: 0x0, symName: _block_destroy_helper, symObjAddr: 0x768, symBinAddr: 0x14048, symSize: 0x8 }
+  - { offsetInCU: 0x329, offset: 0x893DD, size: 0x8, addend: 0x0, symName: '_$s8Dispatch0A13WorkItemFlagsVACs10SetAlgebraAAWl', symObjAddr: 0x770, symBinAddr: 0x14050, symSize: 0x48 }
+  - { offsetInCU: 0x33D, offset: 0x893F1, size: 0x8, addend: 0x0, symName: '_$sSay8Dispatch0A13WorkItemFlagsVGSayxGSTsWl', symObjAddr: 0x7F8, symBinAddr: 0x14098, symSize: 0x4C }
+  - { offsetInCU: 0x351, offset: 0x89405, size: 0x8, addend: 0x0, symName: ___swift_instantiateConcreteTypeFromMangledNameAbstract, symObjAddr: 0x844, symBinAddr: 0x140E4, symSize: 0x44 }
+  - { offsetInCU: 0x365, offset: 0x89419, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_yyScMYccfU0_TA', symObjAddr: 0x8C4, symBinAddr: 0x14128, symSize: 0x24 }
+  - { offsetInCU: 0x399, offset: 0x8944D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_yyScMYccfU_TA', symObjAddr: 0x90C, symBinAddr: 0x14170, symSize: 0x24 }
+  - { offsetInCU: 0x52E, offset: 0x895E2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF4SyncySbs5Int64V_So7UIImageCtFZ', symObjAddr: 0x138, symBinAddr: 0x13A18, symSize: 0x4 }
+  - { offsetInCU: 0x55C, offset: 0x89610, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF4SyncySbs5Int64V_So7UIImageCtFZ', symObjAddr: 0x138, symBinAddr: 0x13A18, symSize: 0x4 }
+  - { offsetInCU: 0x5BB, offset: 0x8966F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZ', symObjAddr: 0x180, symBinAddr: 0x13A60, symSize: 0x4 }
+  - { offsetInCU: 0x5CF, offset: 0x89683, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_', symObjAddr: 0x184, symBinAddr: 0x13A64, symSize: 0x228 }
+  - { offsetInCU: 0x6A8, offset: 0x8975C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCACycfC', symObjAddr: 0x42C, symBinAddr: 0x13D0C, symSize: 0x20 }
+  - { offsetInCU: 0x6BC, offset: 0x89770, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCACycfc', symObjAddr: 0x44C, symBinAddr: 0x13D2C, symSize: 0x30 }
+  - { offsetInCU: 0x6F2, offset: 0x897A6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCfD', symObjAddr: 0x4B8, symBinAddr: 0x13D98, symSize: 0x30 }
+  - { offsetInCU: 0x27, offset: 0x8984C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfC', symObjAddr: 0x0, symBinAddr: 0x141A8, symSize: 0x20 }
+  - { offsetInCU: 0x77, offset: 0x8989C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfcTo', symObjAddr: 0x70, symBinAddr: 0x14218, symSize: 0x3C }
+  - { offsetInCU: 0xC9, offset: 0x898EE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCMa', symObjAddr: 0x50, symBinAddr: 0x141F8, symSize: 0x20 }
+  - { offsetInCU: 0x214, offset: 0x89A39, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfC', symObjAddr: 0x0, symBinAddr: 0x141A8, symSize: 0x20 }
+  - { offsetInCU: 0x228, offset: 0x89A4D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfc', symObjAddr: 0x20, symBinAddr: 0x141C8, symSize: 0x30 }
+  - { offsetInCU: 0x264, offset: 0x89A89, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCfD', symObjAddr: 0xAC, symBinAddr: 0x14254, symSize: 0x30 }
+  - { offsetInCU: 0x26, offset: 0x89AD2, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_frombytes_vartime, symObjAddr: 0x0, symBinAddr: 0x327A64, symSize: 0x265C }
+  - { offsetInCU: 0x40, offset: 0x89AEC, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_k25519Precomp, symObjAddr: 0x9E20, symBinAddr: 0xA19170, symSize: 0x0 }
+  - { offsetInCU: 0x92, offset: 0x89B3E, size: 0x8, addend: 0x0, symName: _d, symObjAddr: 0xFE20, symBinAddr: 0xA1F170, symSize: 0x0 }
+  - { offsetInCU: 0xF6, offset: 0x89BA2, size: 0x8, addend: 0x0, symName: _sqrtm1, symObjAddr: 0xFE48, symBinAddr: 0xA1F198, symSize: 0x0 }
+  - { offsetInCU: 0x10C, offset: 0x89BB8, size: 0x8, addend: 0x0, symName: _d2, symObjAddr: 0x10250, symBinAddr: 0xA1F5A0, symSize: 0x0 }
+  - { offsetInCU: 0x123, offset: 0x89BCF, size: 0x8, addend: 0x0, symName: _Bi, symObjAddr: 0xFE90, symBinAddr: 0xA1F1E0, symSize: 0x0 }
+  - { offsetInCU: 0x9C2, offset: 0x8A46E, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_frombytes_vartime, symObjAddr: 0x0, symBinAddr: 0x327A64, symSize: 0x265C }
+  - { offsetInCU: 0x45D1, offset: 0x8E07D, size: 0x8, addend: 0x0, symName: _fe_frombytes, symObjAddr: 0x265C, symBinAddr: 0x32A0C0, symSize: 0x134 }
+  - { offsetInCU: 0x46F7, offset: 0x8E1A3, size: 0x8, addend: 0x0, symName: _fe_mul_impl, symObjAddr: 0x9954, symBinAddr: 0x3313B8, symSize: 0x21C }
+  - { offsetInCU: 0x4926, offset: 0x8E3D2, size: 0x8, addend: 0x0, symName: _fe_tobytes, symObjAddr: 0x4FE0, symBinAddr: 0x32CA44, symSize: 0x1B8 }
+  - { offsetInCU: 0x5313, offset: 0x8EDBF, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_scalarmult_base, symObjAddr: 0x2790, symBinAddr: 0x32A1F4, symSize: 0x5BC }
+  - { offsetInCU: 0x5F76, offset: 0x8FA22, size: 0x8, addend: 0x0, symName: _table_select, symObjAddr: 0x2D4C, symBinAddr: 0x32A7B0, symSize: 0x7F8 }
+  - { offsetInCU: 0x642E, offset: 0x8FEDA, size: 0x8, addend: 0x0, symName: _ge_madd, symObjAddr: 0x3544, symBinAddr: 0x32AFA8, symSize: 0x208 }
+  - { offsetInCU: 0x69FC, offset: 0x904A8, size: 0x8, addend: 0x0, symName: _ge_p2_dbl, symObjAddr: 0x374C, symBinAddr: 0x32B1B0, symSize: 0x7B4 }
+  - { offsetInCU: 0x77D5, offset: 0x91281, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_sc_reduce, symObjAddr: 0x3F00, symBinAddr: 0x32B964, symSize: 0x634 }
+  - { offsetInCU: 0x8196, offset: 0x91C42, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_scalar_mult_generic_masked, symObjAddr: 0x4534, symBinAddr: 0x32BF98, symSize: 0xAAC }
+  - { offsetInCU: 0x9567, offset: 0x93013, size: 0x8, addend: 0x0, symName: _fe_loose_invert, symObjAddr: 0x529C, symBinAddr: 0x32CD00, symSize: 0x23F8 }
+  - { offsetInCU: 0xCAB8, offset: 0x96564, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_public_from_private_generic_masked, symObjAddr: 0x5198, symBinAddr: 0x32CBFC, symSize: 0x104 }
+  - { offsetInCU: 0xCD20, offset: 0x967CC, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_invert, symObjAddr: 0x7694, symBinAddr: 0x32F0F8, symSize: 0x30 }
+  - { offsetInCU: 0xCE11, offset: 0x968BD, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_isnegative, symObjAddr: 0x76C4, symBinAddr: 0x32F128, symSize: 0x58 }
+  - { offsetInCU: 0xCE86, offset: 0x96932, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_mul_ttt, symObjAddr: 0x771C, symBinAddr: 0x32F180, symSize: 0x4 }
+  - { offsetInCU: 0xCECE, offset: 0x9697A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_mul_ttt, symObjAddr: 0x771C, symBinAddr: 0x32F180, symSize: 0x4 }
+  - { offsetInCU: 0xCEFD, offset: 0x969A9, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_mul_ttt, symObjAddr: 0x771C, symBinAddr: 0x32F180, symSize: 0x4 }
+  - { offsetInCU: 0xCF21, offset: 0x969CD, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_neg, symObjAddr: 0x7720, symBinAddr: 0x32F184, symSize: 0x8C }
+  - { offsetInCU: 0xD056, offset: 0x96B02, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_tobytes, symObjAddr: 0x77AC, symBinAddr: 0x32F210, symSize: 0x4 }
+  - { offsetInCU: 0xD08F, offset: 0x96B3B, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_tobytes, symObjAddr: 0x77AC, symBinAddr: 0x32F210, symSize: 0x4 }
+  - { offsetInCU: 0xD328, offset: 0x96DD4, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_double_scalarmult_vartime, symObjAddr: 0x77B0, symBinAddr: 0x32F214, symSize: 0x15D8 }
+  - { offsetInCU: 0x10671, offset: 0x9A11D, size: 0x8, addend: 0x0, symName: _x25519_ge_add, symObjAddr: 0x9B70, symBinAddr: 0x3315D4, symSize: 0x218 }
+  - { offsetInCU: 0x10CA3, offset: 0x9A74F, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_sc_mask, symObjAddr: 0x8D88, symBinAddr: 0x3307EC, symSize: 0x20 }
+  - { offsetInCU: 0x11140, offset: 0x9ABEC, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_sc_muladd, symObjAddr: 0x8DA8, symBinAddr: 0x33080C, symSize: 0xBAC }
+  - { offsetInCU: 0x26, offset: 0x9B9B7, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_from_montgomery_in_place, symObjAddr: 0x0, symBinAddr: 0x3317EC, symSize: 0x1F4 }
+  - { offsetInCU: 0x1D2, offset: 0x9BB63, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_from_montgomery_in_place, symObjAddr: 0x0, symBinAddr: 0x3317EC, symSize: 0x1F4 }
+  - { offsetInCU: 0x26, offset: 0x9BDFE, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_neg_inv_mod_r_u64, symObjAddr: 0x0, symBinAddr: 0x3319E0, symSize: 0x3C }
+  - { offsetInCU: 0x34, offset: 0x9BE0C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_neg_inv_mod_r_u64, symObjAddr: 0x0, symBinAddr: 0x3319E0, symSize: 0x3C }
+  - { offsetInCU: 0x26, offset: 0x9BF1C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_little_endian_bytes_from_scalar, symObjAddr: 0x0, symBinAddr: 0x331A1C, symSize: 0x98 }
+  - { offsetInCU: 0x34, offset: 0x9BF2A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_little_endian_bytes_from_scalar, symObjAddr: 0x0, symBinAddr: 0x331A1C, symSize: 0x98 }
+  - { offsetInCU: 0x86, offset: 0x9C08D, size: 0x8, addend: 0x0, symName: _Q_N0, symObjAddr: 0x1100, symBinAddr: 0xA1F650, symSize: 0x0 }
+  - { offsetInCU: 0xB8, offset: 0x9C0BF, size: 0x8, addend: 0x0, symName: _Q, symObjAddr: 0x1090, symBinAddr: 0xA1F5E0, symSize: 0x0 }
+  - { offsetInCU: 0xDA, offset: 0x9C0E1, size: 0x8, addend: 0x0, symName: _N, symObjAddr: 0x10C0, symBinAddr: 0xA1F610, symSize: 0x0 }
+  - { offsetInCU: 0xF0, offset: 0x9C0F7, size: 0x8, addend: 0x0, symName: _N_N0, symObjAddr: 0x10F0, symBinAddr: 0xA1F640, symSize: 0x0 }
+  - { offsetInCU: 0x3B7, offset: 0x9C3BE, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_elem_mul_mont, symObjAddr: 0x100, symBinAddr: 0x331AB4, symSize: 0x18 }
+  - { offsetInCU: 0x3FB, offset: 0x9C402, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_elem_mul_mont, symObjAddr: 0x100, symBinAddr: 0x331AB4, symSize: 0x18 }
+  - { offsetInCU: 0x594, offset: 0x9C59B, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_scalar_mul_mont, symObjAddr: 0x1F8, symBinAddr: 0x331ACC, symSize: 0x18 }
+  - { offsetInCU: 0x63F, offset: 0x9C646, size: 0x8, addend: 0x0, symName: _nistz384_point_double, symObjAddr: 0x290, symBinAddr: 0x331AE4, symSize: 0x320 }
+  - { offsetInCU: 0x1173, offset: 0x9D17A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_point_add, symObjAddr: 0x5B0, symBinAddr: 0x331E04, symSize: 0xAC }
+  - { offsetInCU: 0x1469, offset: 0x9D470, size: 0x8, addend: 0x0, symName: _nistz384_point_add, symObjAddr: 0x65C, symBinAddr: 0x331EB0, symSize: 0x500 }
+  - { offsetInCU: 0x2666, offset: 0x9E66D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_point_mul, symObjAddr: 0xB5C, symBinAddr: 0x3323B0, symSize: 0x2C8 }
+  - { offsetInCU: 0x2CB5, offset: 0x9ECBC, size: 0x8, addend: 0x0, symName: _p384_point_select_w5, symObjAddr: 0xE24, symBinAddr: 0x332678, symSize: 0xF4 }
+  - { offsetInCU: 0x2EC7, offset: 0x9EECE, size: 0x8, addend: 0x0, symName: _add_precomputed_w5, symObjAddr: 0xF18, symBinAddr: 0x33276C, symSize: 0x168 }
+  - { offsetInCU: 0x26, offset: 0x9F1F9, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_zero, symObjAddr: 0x0, symBinAddr: 0x3328D4, symSize: 0x38 }
+  - { offsetInCU: 0xFA, offset: 0x9F2CD, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_zero, symObjAddr: 0x0, symBinAddr: 0x3328D4, symSize: 0x38 }
+  - { offsetInCU: 0x12C, offset: 0x9F2FF, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_zero, symObjAddr: 0x0, symBinAddr: 0x3328D4, symSize: 0x38 }
+  - { offsetInCU: 0x199, offset: 0x9F36C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_equal, symObjAddr: 0x38, symBinAddr: 0x33290C, symSize: 0x3C }
+  - { offsetInCU: 0x1F3, offset: 0x9F3C6, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_equal, symObjAddr: 0x38, symBinAddr: 0x33290C, symSize: 0x3C }
+  - { offsetInCU: 0x31B, offset: 0x9F4EE, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_equal_limb, symObjAddr: 0x74, symBinAddr: 0x332948, symSize: 0x5C }
+  - { offsetInCU: 0x517, offset: 0x9F6EA, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_even, symObjAddr: 0xD0, symBinAddr: 0x3329A4, symSize: 0x1C }
+  - { offsetInCU: 0x636, offset: 0x9F809, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_less_than, symObjAddr: 0xEC, symBinAddr: 0x3329C0, symSize: 0x54 }
+  - { offsetInCU: 0x6D9, offset: 0x9F8AC, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_less_than_limb, symObjAddr: 0x140, symBinAddr: 0x332A14, symSize: 0x4C }
+  - { offsetInCU: 0x8A7, offset: 0x9FA7A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_reduce_once, symObjAddr: 0x18C, symBinAddr: 0x332A60, symSize: 0xA8 }
+  - { offsetInCU: 0x90B, offset: 0x9FADE, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_reduce_once, symObjAddr: 0x18C, symBinAddr: 0x332A60, symSize: 0xA8 }
+  - { offsetInCU: 0xBAA, offset: 0x9FD7D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_add_mod, symObjAddr: 0x234, symBinAddr: 0x332B08, symSize: 0x110 }
+  - { offsetInCU: 0xC4C, offset: 0x9FE1F, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_add_mod, symObjAddr: 0x234, symBinAddr: 0x332B08, symSize: 0x110 }
+  - { offsetInCU: 0xEDE, offset: 0xA00B1, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_sub_mod, symObjAddr: 0x344, symBinAddr: 0x332C18, symSize: 0xB0 }
+  - { offsetInCU: 0xF5E, offset: 0xA0131, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_sub_mod, symObjAddr: 0x344, symBinAddr: 0x332C18, symSize: 0xB0 }
+  - { offsetInCU: 0x10E1, offset: 0xA02B4, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_shl_mod, symObjAddr: 0x3F4, symBinAddr: 0x332CC8, symSize: 0x198 }
+  - { offsetInCU: 0x13AB, offset: 0xA057E, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_select_512_32, symObjAddr: 0x58C, symBinAddr: 0x332E60, symSize: 0x290 }
+  - { offsetInCU: 0x1500, offset: 0xA06D3, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_window5_split_window, symObjAddr: 0x81C, symBinAddr: 0x3330F0, symSize: 0x18 }
+  - { offsetInCU: 0x1567, offset: 0xA073A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_window5_unsplit_window, symObjAddr: 0x834, symBinAddr: 0x333108, symSize: 0xC }
+  - { offsetInCU: 0x15A0, offset: 0xA0773, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMB_shr, symObjAddr: 0x840, symBinAddr: 0x333114, symSize: 0x8 }
+  - { offsetInCU: 0x1624, offset: 0xA07F7, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_limbs_mul_add_limb, symObjAddr: 0x848, symBinAddr: 0x33311C, symSize: 0x3C }
+  - { offsetInCU: 0x26, offset: 0xA09AA, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_CRYPTO_memcmp, symObjAddr: 0x0, symBinAddr: 0x333158, symSize: 0x190 }
+  - { offsetInCU: 0x34, offset: 0xA09B8, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_CRYPTO_memcmp, symObjAddr: 0x0, symBinAddr: 0x333158, symSize: 0x190 }
+  - { offsetInCU: 0x34, offset: 0xA0ABE, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_OPENSSL_armcap_P, symObjAddr: 0x398, symBinAddr: 0x1157298, symSize: 0x0 }
+  - { offsetInCU: 0x26, offset: 0xA0B00, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul, symObjAddr: 0x0, symBinAddr: 0x3332E8, symSize: 0x388 }
+  - { offsetInCU: 0x76, offset: 0xA0B50, size: 0x8, addend: 0x0, symName: _ecp_nistz256_precomputed, symObjAddr: 0x1000, symBinAddr: 0xA20000, symSize: 0x0 }
+  - { offsetInCU: 0xFA, offset: 0xA0BD4, size: 0x8, addend: 0x0, symName: _ONE, symObjAddr: 0x26000, symBinAddr: 0xA45000, symSize: 0x0 }
+  - { offsetInCU: 0x35B, offset: 0xA0E35, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul, symObjAddr: 0x0, symBinAddr: 0x3332E8, symSize: 0x388 }
+  - { offsetInCU: 0xC66, offset: 0xA1740, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul_base, symObjAddr: 0x388, symBinAddr: 0x333670, symSize: 0x204 }
+  - { offsetInCU: 0x1163, offset: 0xA1C3D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul_base_vartime, symObjAddr: 0x58C, symBinAddr: 0x333874, symSize: 0x1BC }
+  - { offsetInCU: 0x10, offset: 0xA2012, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_set_encrypt_key, symObjAddr: 0x0, symBinAddr: 0x333A40, symSize: 0x1A0 }
+  - { offsetInCU: 0x50, offset: 0xA2052, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_set_encrypt_key, symObjAddr: 0x0, symBinAddr: 0x333A40, symSize: 0x1A0 }
+  - { offsetInCU: 0x5E, offset: 0xA2060, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_encrypt, symObjAddr: 0x1A0, symBinAddr: 0x333BE0, symSize: 0x60 }
+  - { offsetInCU: 0x81, offset: 0xA2083, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_ctr32_encrypt_blocks, symObjAddr: 0x200, symBinAddr: 0x333C40, symSize: 0x288 }
+  - { offsetInCU: 0x10, offset: 0xA2074, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_init_clmul, symObjAddr: 0x0, symBinAddr: 0x333ED0, symSize: 0x130 }
+  - { offsetInCU: 0x48, offset: 0xA20AC, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_init_clmul, symObjAddr: 0x0, symBinAddr: 0x333ED0, symSize: 0x130 }
+  - { offsetInCU: 0x5F, offset: 0xA20C3, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_gmult_clmul, symObjAddr: 0x130, symBinAddr: 0x334000, symSize: 0x70 }
+  - { offsetInCU: 0x75, offset: 0xA20D9, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_ghash_clmul, symObjAddr: 0x1A0, symBinAddr: 0x334070, symSize: 0x160 }
+  - { offsetInCU: 0x7A, offset: 0xA20DE, size: 0x8, addend: 0x0, symName: gcm_ghash_v8_4x, symObjAddr: 0x300, symBinAddr: 0x3341D0, symSize: 0x378 }
+  - { offsetInCU: 0x10, offset: 0xA20EC, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ChaCha20_ctr32, symObjAddr: 0x0, symBinAddr: 0x334560, symSize: 0x3A0 }
+  - { offsetInCU: 0x48, offset: 0xA2124, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ChaCha20_ctr32, symObjAddr: 0x0, symBinAddr: 0x334560, symSize: 0x3A0 }
+  - { offsetInCU: 0x4C, offset: 0xA2128, size: 0x8, addend: 0x0, symName: ChaCha20_neon, symObjAddr: 0x3A0, symBinAddr: 0x334900, symSize: 0x6C0 }
+  - { offsetInCU: 0x66, offset: 0xA2142, size: 0x8, addend: 0x0, symName: ChaCha20_512_neon, symObjAddr: 0xA60, symBinAddr: 0x334FC0, symSize: 0x1138 }
+  - { offsetInCU: 0x50, offset: 0xA218E, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_chacha20_poly1305_seal, symObjAddr: 0x140, symBinAddr: 0x336240, symSize: 0x1180 }
+  - { offsetInCU: 0x66, offset: 0xA21A4, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_chacha20_poly1305_open, symObjAddr: 0x12C0, symBinAddr: 0x3373C0, symSize: 0x1410 }
+  - { offsetInCU: 0x10, offset: 0xA219A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_mul_mont, symObjAddr: 0x0, symBinAddr: 0x3387E0, symSize: 0x240 }
+  - { offsetInCU: 0x45, offset: 0xA21CF, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_mul_mont, symObjAddr: 0x0, symBinAddr: 0x3387E0, symSize: 0x240 }
+  - { offsetInCU: 0x4D, offset: 0xA21D7, size: 0x8, addend: 0x0, symName: __bn_sqr8x_mont, symObjAddr: 0x240, symBinAddr: 0x338A20, symSize: 0x9E0 }
+  - { offsetInCU: 0x63, offset: 0xA21ED, size: 0x8, addend: 0x0, symName: __bn_mul4x_mont, symObjAddr: 0xC20, symBinAddr: 0x339400, symSize: 0x650 }
+  - { offsetInCU: 0x10, offset: 0xA21FC, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_mul_mont, symObjAddr: 0x0, symBinAddr: 0x339A60, symSize: 0x40 }
+  - { offsetInCU: 0x47, offset: 0xA2233, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_mul_mont, symObjAddr: 0x0, symBinAddr: 0x339A60, symSize: 0x40 }
+  - { offsetInCU: 0x5D, offset: 0xA2249, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_sqr_mont, symObjAddr: 0x40, symBinAddr: 0x339AA0, symSize: 0x40 }
+  - { offsetInCU: 0x76, offset: 0xA2262, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ecp_nistz256_neg, symObjAddr: 0x80, symBinAddr: 0x339AE0, symSize: 0x40 }
+  - { offsetInCU: 0x81, offset: 0xA226D, size: 0x8, addend: 0x0, symName: __ecp_nistz256_mul_mont, symObjAddr: 0xC0, symBinAddr: 0x339B20, symSize: 0x1E0 }
+  - { offsetInCU: 0x97, offset: 0xA2283, size: 0x8, addend: 0x0, symName: __ecp_nistz256_sqr_mont, symObjAddr: 0x2A0, symBinAddr: 0x339D00, symSize: 0x170 }
+  - { offsetInCU: 0xAB, offset: 0xA2297, size: 0x8, addend: 0x0, symName: __ecp_nistz256_add_to, symObjAddr: 0x410, symBinAddr: 0x339E70, symSize: 0x50 }
+  - { offsetInCU: 0xC3, offset: 0xA22AF, size: 0x8, addend: 0x0, symName: __ecp_nistz256_sub_from, symObjAddr: 0x460, symBinAddr: 0x339EC0, symSize: 0x50 }
+  - { offsetInCU: 0xD9, offset: 0xA22C5, size: 0x8, addend: 0x0, symName: __ecp_nistz256_sub_morf, symObjAddr: 0x4B0, symBinAddr: 0x339F10, symSize: 0x50 }
+  - { offsetInCU: 0xEF, offset: 0xA22DB, size: 0x8, addend: 0x0, symName: __ecp_nistz256_div_by_2, symObjAddr: 0x500, symBinAddr: 0x339F60, symSize: 0x60 }
+  - { offsetInCU: 0x111, offset: 0xA22FD, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_double, symObjAddr: 0x560, symBinAddr: 0x339FC0, symSize: 0x1E0 }
+  - { offsetInCU: 0x124, offset: 0xA2310, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_add, symObjAddr: 0x740, symBinAddr: 0x33A1A0, symSize: 0x360 }
+  - { offsetInCU: 0x141, offset: 0xA232D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_add_affine, symObjAddr: 0xAA0, symBinAddr: 0x33A500, symSize: 0x2D0 }
+  - { offsetInCU: 0x156, offset: 0xA2342, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_scalar_mul_mont, symObjAddr: 0xD70, symBinAddr: 0x33A7D0, symSize: 0x2B0 }
+  - { offsetInCU: 0x170, offset: 0xA235C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_scalar_sqr_rep_mont, symObjAddr: 0x1020, symBinAddr: 0x33AA80, symSize: 0x250 }
+  - { offsetInCU: 0x184, offset: 0xA2370, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ecp_nistz256_select_w5, symObjAddr: 0x1270, symBinAddr: 0x33ACD0, symSize: 0x60 }
+  - { offsetInCU: 0x19A, offset: 0xA2386, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ecp_nistz256_select_w7, symObjAddr: 0x12D0, symBinAddr: 0x33AD30, symSize: 0x44 }
+  - { offsetInCU: 0x10, offset: 0xA237C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_gcm_enc_kernel, symObjAddr: 0x0, symBinAddr: 0x33AD80, symSize: 0xB90 }
+  - { offsetInCU: 0x4C, offset: 0xA23B8, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_gcm_enc_kernel, symObjAddr: 0x0, symBinAddr: 0x33AD80, symSize: 0xB90 }
+  - { offsetInCU: 0x62, offset: 0xA23CE, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_gcm_dec_kernel, symObjAddr: 0xB90, symBinAddr: 0x33B910, symSize: 0xB98 }
+  - { offsetInCU: 0x10, offset: 0xA23C8, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha512_block_data_order, symObjAddr: 0x0, symBinAddr: 0x33C4C0, symSize: 0xE40 }
+  - { offsetInCU: 0x51, offset: 0xA2409, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha512_block_data_order, symObjAddr: 0x0, symBinAddr: 0x33C4C0, symSize: 0xE40 }
+  - { offsetInCU: 0x51, offset: 0xA2409, size: 0x8, addend: 0x0, symName: sha512_block_armv8, symObjAddr: 0xE40, symBinAddr: 0x33D300, symSize: 0x7E0 }
+  - { offsetInCU: 0x10, offset: 0xA2414, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha256_block_data_order, symObjAddr: 0x0, symBinAddr: 0x33DB00, symSize: 0xE40 }
+  - { offsetInCU: 0x51, offset: 0xA2455, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha256_block_data_order, symObjAddr: 0x0, symBinAddr: 0x33DB00, symSize: 0xE40 }
+  - { offsetInCU: 0x51, offset: 0xA2455, size: 0x8, addend: 0x0, symName: sha256_block_armv8, symObjAddr: 0xE40, symBinAddr: 0x33E940, symSize: 0x1F0 }
 ...
diff --git a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/Relocations/x86_64/CanvasNative.yml b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/Relocations/x86_64/CanvasNative.yml
index 0e5e3fa18..8788de0b8 100644
--- a/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/Relocations/x86_64/CanvasNative.yml
+++ b/packages/canvas/src-native/canvas-ios/dist/CanvasNative.xcframework/ios-arm64_x86_64-simulator/dSYMs/CanvasNative.framework.dSYM/Contents/Resources/Relocations/x86_64/CanvasNative.yml
@@ -2,642 +2,642 @@
 triple:          'x86_64-apple-darwin'
 binary-path:     '/Users/triniwiz/Documents/GitHub/canvas/packages/canvas/src-native/canvas-ios/dist/Release-iphonesimulator/CanvasNative.framework/CanvasNative'
 relocations:
-  - { offsetInCU: 0x34, offset: 0x78EE9, size: 0x8, addend: 0x0, symName: _CanvasNativeVersionString, symObjAddr: 0x0, symBinAddr: 0xA1F000, symSize: 0x0 }
-  - { offsetInCU: 0x69, offset: 0x78F1E, size: 0x8, addend: 0x0, symName: _CanvasNativeVersionNumber, symObjAddr: 0x38, symBinAddr: 0xA1F038, symSize: 0x0 }
-  - { offsetInCU: 0x3F, offset: 0x78F73, size: 0x8, addend: 0x0, symName: ___swift_memcpy16_8, symObjAddr: 0x40, symBinAddr: 0x1D80, symSize: 0x10 }
-  - { offsetInCU: 0x53, offset: 0x78F87, size: 0x8, addend: 0x0, symName: ___swift_noop_void_return, symObjAddr: 0x50, symBinAddr: 0x1D90, symSize: 0x10 }
-  - { offsetInCU: 0x67, offset: 0x78F9B, size: 0x8, addend: 0x0, symName: '_$sSo6CGSizeVwet', symObjAddr: 0x60, symBinAddr: 0x1DA0, symSize: 0x20 }
-  - { offsetInCU: 0x7B, offset: 0x78FAF, size: 0x8, addend: 0x0, symName: '_$sSo6CGSizeVwst', symObjAddr: 0x80, symBinAddr: 0x1DC0, symSize: 0x30 }
-  - { offsetInCU: 0x8F, offset: 0x78FC3, size: 0x8, addend: 0x0, symName: '_$sSo6CGRectVwCP', symObjAddr: 0xD0, symBinAddr: 0x1E10, symSize: 0x30 }
-  - { offsetInCU: 0xA3, offset: 0x78FD7, size: 0x8, addend: 0x0, symName: ___swift_memcpy32_8, symObjAddr: 0x100, symBinAddr: 0x1E40, symSize: 0x20 }
-  - { offsetInCU: 0xB7, offset: 0x78FEB, size: 0x8, addend: 0x0, symName: '_$sSo6CGRectVwet', symObjAddr: 0x120, symBinAddr: 0x1E60, symSize: 0x20 }
-  - { offsetInCU: 0xCB, offset: 0x78FFF, size: 0x8, addend: 0x0, symName: '_$sSo6CGRectVwst', symObjAddr: 0x140, symBinAddr: 0x1E80, symSize: 0x30 }
-  - { offsetInCU: 0x4F, offset: 0x791E8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC11_WriteQueue33_05178D28796EA758448493B56DC45144LLSo011NSOperationE0CSgvpZ', symObjAddr: 0x30B0, symBinAddr: 0x12D2E60, symSize: 0x0 }
-  - { offsetInCU: 0x69, offset: 0x79202, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10_ReadQueue33_05178D28796EA758448493B56DC45144LLSo011NSOperationE0CSgvpZ', symObjAddr: 0x30B8, symBinAddr: 0x12D2E68, symSize: 0x0 }
-  - { offsetInCU: 0x9D, offset: 0x79236, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC19getBytesFromUIImageySo13NSMutableDataCSo0G0CFZTo', symObjAddr: 0x10, symBinAddr: 0x1F50, symSize: 0x40 }
-  - { offsetInCU: 0xF3, offset: 0x7928C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13createPatternys5Int64VAF_So7UIImageCSStFZTo', symObjAddr: 0x60, symBinAddr: 0x1FA0, symSize: 0x60 }
-  - { offsetInCU: 0x144, offset: 0x792DD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC25loadImageAssetWithContextySbs5Int64V_So7UIImageCtFZTo', symObjAddr: 0xD0, symBinAddr: 0x2010, symSize: 0x40 }
-  - { offsetInCU: 0x19F, offset: 0x79338, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dyys5Int64V_So7UIImageCS2ftFZTo', symObjAddr: 0x120, symBinAddr: 0x2060, symSize: 0x50 }
-  - { offsetInCU: 0x204, offset: 0x7939D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dy2dw2dhys5Int64V_So7UIImageCS4ftFZTo', symObjAddr: 0x180, symBinAddr: 0x20C0, symSize: 0x60 }
-  - { offsetInCU: 0x27D, offset: 0x79416, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2sx2sy2sw2sh2dx2dy2dw2dhys5Int64V_So7UIImageCS8ftFZTo', symObjAddr: 0x1F0, symBinAddr: 0x2130, symSize: 0x90 }
-  - { offsetInCU: 0x2DA, offset: 0x79473, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23initWebGPUWithViewLayerys5Int64VAF_AFs6UInt32VAHtFZTo', symObjAddr: 0x290, symBinAddr: 0x21D0, symSize: 0x20 }
-  - { offsetInCU: 0x35C, offset: 0x794F5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC18initWebGPUWithViewys5Int64VAF_AFs6UInt32VAHtFZTo', symObjAddr: 0x2C0, symBinAddr: 0x2200, symSize: 0x20 }
-  - { offsetInCU: 0x40B, offset: 0x795A4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14initGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbtFZTo', symObjAddr: 0x350, symBinAddr: 0x2290, symSize: 0x80 }
-  - { offsetInCU: 0x4D0, offset: 0x79669, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC20initSharedGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbAFtFZTo', symObjAddr: 0x440, symBinAddr: 0x2380, symSize: 0x80 }
-  - { offsetInCU: 0x59F, offset: 0x79738, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC24initGLWithWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbtFZTo', symObjAddr: 0x530, symBinAddr: 0x2470, symSize: 0x80 }
-  - { offsetInCU: 0x669, offset: 0x79802, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC26initSharedGLWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbAFtFZTo', symObjAddr: 0x630, symBinAddr: 0x2570, symSize: 0x90 }
-  - { offsetInCU: 0x701, offset: 0x7989A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15resize2DContextyys5Int64V_S2ftFZTo', symObjAddr: 0x6D0, symBinAddr: 0x2610, symSize: 0x10 }
-  - { offsetInCU: 0x768, offset: 0x79901, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14flush2DContextyys5Int64VFZTo', symObjAddr: 0x6F0, symBinAddr: 0x2630, symSize: 0x10 }
-  - { offsetInCU: 0x7BF, offset: 0x79958, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC7flushGLySbs5Int64VFZTo', symObjAddr: 0x710, symBinAddr: 0x2650, symSize: 0x10 }
-  - { offsetInCU: 0x816, offset: 0x799AF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9releaseGLyys5Int64VFZTo', symObjAddr: 0x730, symBinAddr: 0x2670, symSize: 0x10 }
-  - { offsetInCU: 0x86D, offset: 0x79A06, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC12getGLPointerys5Int64VAFFZTo', symObjAddr: 0x750, symBinAddr: 0x2690, symSize: 0x10 }
-  - { offsetInCU: 0x8C4, offset: 0x79A5D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC16releaseGLPointeryys5Int64VFZTo', symObjAddr: 0x770, symBinAddr: 0x26B0, symSize: 0x10 }
-  - { offsetInCU: 0x943, offset: 0x79ADC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15create2DContextys5Int64VAF_s5Int32VAHSbSfA2HSfAHtFZTo', symObjAddr: 0x790, symBinAddr: 0x26D0, symSize: 0x40 }
-  - { offsetInCU: 0x9EE, offset: 0x79B87, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23updateGLSurfaceWithViewyys5Int64V_s5Int32VAhFtFZTo', symObjAddr: 0x7E0, symBinAddr: 0x2720, symSize: 0x20 }
-  - { offsetInCU: 0xA61, offset: 0x79BFA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC6test2Dyys5Int64VFZTo', symObjAddr: 0x810, symBinAddr: 0x2750, symSize: 0x10 }
-  - { offsetInCU: 0xAB8, offset: 0x79C51, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13testToDataURLySSs5Int64VFZTo', symObjAddr: 0x880, symBinAddr: 0x27C0, symSize: 0x70 }
-  - { offsetInCU: 0xB43, offset: 0x79CDC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZTo', symObjAddr: 0xA90, symBinAddr: 0x29D0, symSize: 0xA0 }
-  - { offsetInCU: 0xB94, offset: 0x79D2D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZTo', symObjAddr: 0xD90, symBinAddr: 0x2CD0, symSize: 0xA0 }
-  - { offsetInCU: 0xBE5, offset: 0x79D7E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZTo', symObjAddr: 0x10F0, symBinAddr: 0x3030, symSize: 0xA0 }
-  - { offsetInCU: 0xC41, offset: 0x79DDA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZTo', symObjAddr: 0x1540, symBinAddr: 0x3480, symSize: 0xD0 }
-  - { offsetInCU: 0xC89, offset: 0x79E22, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC32getPixelsPerInchForCurrentDeviceSSyFZTo', symObjAddr: 0x1620, symBinAddr: 0x3560, symSize: 0x40 }
-  - { offsetInCU: 0xCE9, offset: 0x79E82, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCACycfcTo', symObjAddr: 0x16B0, symBinAddr: 0x35F0, symSize: 0x30 }
-  - { offsetInCU: 0xD3C, offset: 0x79ED5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC19getBytesFromUIImageySo13NSMutableDataCSo0G0CFZTf4nd_n', symObjAddr: 0x1720, symBinAddr: 0x3660, symSize: 0x300 }
-  - { offsetInCU: 0xF6C, offset: 0x7A105, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13createPatternys5Int64VAF_So7UIImageCSStFZTf4nnnd_n', symObjAddr: 0x1A20, symBinAddr: 0x3960, symSize: 0x260 }
-  - { offsetInCU: 0x1166, offset: 0x7A2FF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC25loadImageAssetWithContextySbs5Int64V_So7UIImageCtFZTf4nnd_n', symObjAddr: 0x1C80, symBinAddr: 0x3BC0, symSize: 0xD0 }
-  - { offsetInCU: 0x1263, offset: 0x7A3FC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dyys5Int64V_So7UIImageCS2ftFZTf4nnnnd_n', symObjAddr: 0x1D50, symBinAddr: 0x3C90, symSize: 0x1B0 }
-  - { offsetInCU: 0x13D8, offset: 0x7A571, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dy2dw2dhys5Int64V_So7UIImageCS4ftFZTf4nnnnnnd_n', symObjAddr: 0x1F00, symBinAddr: 0x3E40, symSize: 0x1D0 }
-  - { offsetInCU: 0x156D, offset: 0x7A706, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2sx2sy2sw2sh2dx2dy2dw2dhys5Int64V_So7UIImageCS8ftFZTf4nnnnnnnnnnd_n', symObjAddr: 0x20D0, symBinAddr: 0x4010, symSize: 0x200 }
-  - { offsetInCU: 0x1759, offset: 0x7A8F2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZTf4nnnd_n', symObjAddr: 0x22D0, symBinAddr: 0x4210, symSize: 0x1D0 }
-  - { offsetInCU: 0x1823, offset: 0x7A9BC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZTf4nnnnd_n', symObjAddr: 0x2660, symBinAddr: 0x45A0, symSize: 0x200 }
-  - { offsetInCU: 0x1904, offset: 0x7AA9D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC32getPixelsPerInchForCurrentDeviceSSyFZTf4d_n', symObjAddr: 0x2860, symBinAddr: 0x47A0, symSize: 0x110 }
-  - { offsetInCU: 0x19AF, offset: 0x7AB48, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgACIeyByy_SSSgADIeggg_TR', symObjAddr: 0xB30, symBinAddr: 0x2A70, symSize: 0x70 }
-  - { offsetInCU: 0x19C7, offset: 0x7AB60, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgSo6NSDataCSgIeyByy_SSSgAFIeggg_TR', symObjAddr: 0xE30, symBinAddr: 0x2D70, symSize: 0x50 }
-  - { offsetInCU: 0x1A34, offset: 0x7ABCD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCfETo', symObjAddr: 0x1710, symBinAddr: 0x3650, symSize: 0x10 }
-  - { offsetInCU: 0x1ABF, offset: 0x7AC58, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCMa', symObjAddr: 0x2970, symBinAddr: 0x48B0, symSize: 0x20 }
-  - { offsetInCU: 0x1AD3, offset: 0x7AC6C, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgACIeyByy_SSSgADIeggg_TRTA', symObjAddr: 0x29B0, symBinAddr: 0x48F0, symSize: 0x10 }
-  - { offsetInCU: 0x1AF2, offset: 0x7AC8B, size: 0x8, addend: 0x0, symName: '_$sSo7NSErrorCSg10ObjectiveC8ObjCBoolVIeyByy_ACSbIeggy_TRTA', symObjAddr: 0x29C0, symBinAddr: 0x4900, symSize: 0x20 }
-  - { offsetInCU: 0x1B1B, offset: 0x7ACB4, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgSo6NSDataCSgIeyByy_SSSgAFIeggg_TRTA', symObjAddr: 0x29E0, symBinAddr: 0x4920, symSize: 0x10 }
-  - { offsetInCU: 0x1B2F, offset: 0x7ACC8, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCMa', symObjAddr: 0x29F0, symBinAddr: 0x4930, symSize: 0x30 }
-  - { offsetInCU: 0x1B43, offset: 0x7ACDC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZyyYbcfU_TA', symObjAddr: 0x2A70, symBinAddr: 0x49B0, symSize: 0x40 }
-  - { offsetInCU: 0x1B57, offset: 0x7ACF0, size: 0x8, addend: 0x0, symName: _block_copy_helper, symObjAddr: 0x2AB0, symBinAddr: 0x49F0, symSize: 0x20 }
-  - { offsetInCU: 0x1B6B, offset: 0x7AD04, size: 0x8, addend: 0x0, symName: _block_destroy_helper, symObjAddr: 0x2AD0, symBinAddr: 0x4A10, symSize: 0x10 }
-  - { offsetInCU: 0x1B7F, offset: 0x7AD18, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZyyYbcfU_yyYbcfU0_TA', symObjAddr: 0x2B00, symBinAddr: 0x4A40, symSize: 0x40 }
-  - { offsetInCU: 0x1BB3, offset: 0x7AD4C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZyyYbcfU_yyYbcfU0_TA', symObjAddr: 0x2BC0, symBinAddr: 0x4B00, symSize: 0x40 }
-  - { offsetInCU: 0x1BF1, offset: 0x7AD8A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZyyYbcfU_yyYbcfU_TA', symObjAddr: 0x2C00, symBinAddr: 0x4B40, symSize: 0x20 }
-  - { offsetInCU: 0x1C25, offset: 0x7ADBE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZyyYbcfU_yyYbcfU_TA', symObjAddr: 0x2CB0, symBinAddr: 0x4BF0, symSize: 0x40 }
-  - { offsetInCU: 0x1C59, offset: 0x7ADF2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZyyYbcfU_yyYbcfU0_TA', symObjAddr: 0x2D20, symBinAddr: 0x4C60, symSize: 0x30 }
-  - { offsetInCU: 0x1C95, offset: 0x7AE2E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZyyYbcfU_TA', symObjAddr: 0x2DA0, symBinAddr: 0x4CE0, symSize: 0x30 }
-  - { offsetInCU: 0x1CA9, offset: 0x7AE42, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZyyYbcfU_yyYbcfU_TA', symObjAddr: 0x2DD0, symBinAddr: 0x4D10, symSize: 0x40 }
-  - { offsetInCU: 0x2176, offset: 0x7B30F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC19getBytesFromUIImageySo13NSMutableDataCSo0G0CFZ', symObjAddr: 0x0, symBinAddr: 0x1F40, symSize: 0x10 }
-  - { offsetInCU: 0x2191, offset: 0x7B32A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x50, symBinAddr: 0x1F90, symSize: 0x10 }
-  - { offsetInCU: 0x21AC, offset: 0x7B345, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC25loadImageAssetWithContextySbs5Int64V_So7UIImageCtFZ', symObjAddr: 0xC0, symBinAddr: 0x2000, symSize: 0x10 }
-  - { offsetInCU: 0x21CD, offset: 0x7B366, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dyys5Int64V_So7UIImageCS2ftFZ', symObjAddr: 0x110, symBinAddr: 0x2050, symSize: 0x10 }
-  - { offsetInCU: 0x21E8, offset: 0x7B381, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dy2dw2dhys5Int64V_So7UIImageCS4ftFZ', symObjAddr: 0x170, symBinAddr: 0x20B0, symSize: 0x10 }
-  - { offsetInCU: 0x2203, offset: 0x7B39C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2sx2sy2sw2sh2dx2dy2dw2dhys5Int64V_So7UIImageCS8ftFZ', symObjAddr: 0x1E0, symBinAddr: 0x2120, symSize: 0x10 }
-  - { offsetInCU: 0x221E, offset: 0x7B3B7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23initWebGPUWithViewLayerys5Int64VAF_AFs6UInt32VAHtFZ', symObjAddr: 0x280, symBinAddr: 0x21C0, symSize: 0x10 }
-  - { offsetInCU: 0x22AC, offset: 0x7B445, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC18initWebGPUWithViewys5Int64VAF_AFs6UInt32VAHtFZ', symObjAddr: 0x2B0, symBinAddr: 0x21F0, symSize: 0x10 }
-  - { offsetInCU: 0x232B, offset: 0x7B4C4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14initGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbtFZ', symObjAddr: 0x2E0, symBinAddr: 0x2220, symSize: 0x70 }
-  - { offsetInCU: 0x247D, offset: 0x7B616, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC20initSharedGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbAFtFZ', symObjAddr: 0x3D0, symBinAddr: 0x2310, symSize: 0x70 }
-  - { offsetInCU: 0x25DB, offset: 0x7B774, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC24initGLWithWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbtFZ', symObjAddr: 0x4C0, symBinAddr: 0x2400, symSize: 0x70 }
-  - { offsetInCU: 0x2739, offset: 0x7B8D2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC26initSharedGLWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbAFtFZ', symObjAddr: 0x5B0, symBinAddr: 0x24F0, symSize: 0x80 }
-  - { offsetInCU: 0x28AD, offset: 0x7BA46, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15resize2DContextyys5Int64V_S2ftFZ', symObjAddr: 0x6C0, symBinAddr: 0x2600, symSize: 0x10 }
-  - { offsetInCU: 0x291D, offset: 0x7BAB6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14flush2DContextyys5Int64VFZ', symObjAddr: 0x6E0, symBinAddr: 0x2620, symSize: 0x10 }
-  - { offsetInCU: 0x2960, offset: 0x7BAF9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC7flushGLySbs5Int64VFZ', symObjAddr: 0x700, symBinAddr: 0x2640, symSize: 0x10 }
-  - { offsetInCU: 0x29A5, offset: 0x7BB3E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9releaseGLyys5Int64VFZ', symObjAddr: 0x720, symBinAddr: 0x2660, symSize: 0x10 }
-  - { offsetInCU: 0x29E8, offset: 0x7BB81, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC12getGLPointerys5Int64VAFFZ', symObjAddr: 0x740, symBinAddr: 0x2680, symSize: 0x10 }
-  - { offsetInCU: 0x2A2B, offset: 0x7BBC4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC16releaseGLPointeryys5Int64VFZ', symObjAddr: 0x760, symBinAddr: 0x26A0, symSize: 0x10 }
-  - { offsetInCU: 0x2A6E, offset: 0x7BC07, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15create2DContextys5Int64VAF_s5Int32VAHSbSfA2HSfAHtFZ', symObjAddr: 0x780, symBinAddr: 0x26C0, symSize: 0x10 }
-  - { offsetInCU: 0x2B54, offset: 0x7BCED, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23updateGLSurfaceWithViewyys5Int64V_s5Int32VAhFtFZ', symObjAddr: 0x7D0, symBinAddr: 0x2710, symSize: 0x10 }
-  - { offsetInCU: 0x2BD3, offset: 0x7BD6C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC6test2Dyys5Int64VFZ', symObjAddr: 0x800, symBinAddr: 0x2740, symSize: 0x10 }
-  - { offsetInCU: 0x2C16, offset: 0x7BDAF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13testToDataURLySSs5Int64VFZ', symObjAddr: 0x820, symBinAddr: 0x2760, symSize: 0x60 }
-  - { offsetInCU: 0x2CD7, offset: 0x7BE70, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZ', symObjAddr: 0x8F0, symBinAddr: 0x2830, symSize: 0x10 }
-  - { offsetInCU: 0x2CEB, offset: 0x7BE84, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZyyYbcfU_', symObjAddr: 0x900, symBinAddr: 0x2840, symSize: 0x190 }
-  - { offsetInCU: 0x2D8B, offset: 0x7BF24, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZ', symObjAddr: 0xBA0, symBinAddr: 0x2AE0, symSize: 0x30 }
-  - { offsetInCU: 0x2D9F, offset: 0x7BF38, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZyyYbcfU_', symObjAddr: 0xBD0, symBinAddr: 0x2B10, symSize: 0x1C0 }
-  - { offsetInCU: 0x2E89, offset: 0x7C022, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZ', symObjAddr: 0xE80, symBinAddr: 0x2DC0, symSize: 0x30 }
-  - { offsetInCU: 0x2E9D, offset: 0x7C036, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZyyYbcfU_', symObjAddr: 0xEB0, symBinAddr: 0x2DF0, symSize: 0x240 }
-  - { offsetInCU: 0x2F51, offset: 0x7C0EA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZ', symObjAddr: 0x1190, symBinAddr: 0x30D0, symSize: 0x10 }
-  - { offsetInCU: 0x2F65, offset: 0x7C0FE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZyyYbcfU_', symObjAddr: 0x11A0, symBinAddr: 0x30E0, symSize: 0x3A0 }
-  - { offsetInCU: 0x31FB, offset: 0x7C394, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC32getPixelsPerInchForCurrentDeviceSSyFZ', symObjAddr: 0x1610, symBinAddr: 0x3550, symSize: 0x10 }
-  - { offsetInCU: 0x3216, offset: 0x7C3AF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCACycfC', symObjAddr: 0x1660, symBinAddr: 0x35A0, symSize: 0x20 }
-  - { offsetInCU: 0x322A, offset: 0x7C3C3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCACycfc', symObjAddr: 0x1680, symBinAddr: 0x35C0, symSize: 0x30 }
-  - { offsetInCU: 0x3260, offset: 0x7C3F9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCfD', symObjAddr: 0x16E0, symBinAddr: 0x3620, symSize: 0x30 }
-  - { offsetInCU: 0x4F, offset: 0x7C631, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19shared_context_view33_508084857CA7D194CA72FEB80DD78002LLSo7GLKViewCvpZ', symObjAddr: 0x5C38, symBinAddr: 0x12D2EA0, symSize: 0x0 }
-  - { offsetInCU: 0x69, offset: 0x7C64B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15_shared_context33_508084857CA7D194CA72FEB80DD78002LLs5Int64VvpZ', symObjAddr: 0x5C40, symBinAddr: 0x12D2EA8, symSize: 0x0 }
-  - { offsetInCU: 0x83, offset: 0x7C665, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5storeSo19NSMutableDictionaryCvpZ', symObjAddr: 0x5C48, symBinAddr: 0x12D2EB0, symSize: 0x0 }
-  - { offsetInCU: 0x9D, offset: 0x7C67F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5views33_508084857CA7D194CA72FEB80DD78002LLSo10NSMapTableCySo8NSStringCACGvpZ', symObjAddr: 0x5C50, symBinAddr: 0x12D2EB8, symSize: 0x0 }
-  - { offsetInCU: 0xAB, offset: 0x7C68D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19shared_context_view33_508084857CA7D194CA72FEB80DD78002LL_WZ', symObjAddr: 0x0, symBinAddr: 0x4FE0, symSize: 0x60 }
-  - { offsetInCU: 0xF0, offset: 0x7C6D2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5store_WZ', symObjAddr: 0x60, symBinAddr: 0x5040, symSize: 0x30 }
-  - { offsetInCU: 0x135, offset: 0x7C717, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5views33_508084857CA7D194CA72FEB80DD78002LL_WZ', symObjAddr: 0xD0, symBinAddr: 0x50B0, symSize: 0x40 }
-  - { offsetInCU: 0x187, offset: 0x7C769, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC3ptrSvSgvgTo', symObjAddr: 0x1B0, symBinAddr: 0x5190, symSize: 0x20 }
-  - { offsetInCU: 0x1DD, offset: 0x7C7BF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC3ptrSvSgvsTo', symObjAddr: 0x1D0, symBinAddr: 0x51B0, symSize: 0x20 }
-  - { offsetInCU: 0x236, offset: 0x7C818, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6mtlPtrSvSgvgTo', symObjAddr: 0x1F0, symBinAddr: 0x51D0, symSize: 0x20 }
-  - { offsetInCU: 0x28C, offset: 0x7C86E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6mtlPtrSvSgvsTo', symObjAddr: 0x210, symBinAddr: 0x51F0, symSize: 0x20 }
-  - { offsetInCU: 0x2E5, offset: 0x7C8C7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvgTo', symObjAddr: 0x320, symBinAddr: 0x5300, symSize: 0x40 }
-  - { offsetInCU: 0x320, offset: 0x7C902, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvsTo', symObjAddr: 0x390, symBinAddr: 0x5370, symSize: 0x30 }
-  - { offsetInCU: 0x3AF, offset: 0x7C991, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8nativeGLs5Int64VvgTo', symObjAddr: 0x5D0, symBinAddr: 0x55B0, symSize: 0x40 }
-  - { offsetInCU: 0x405, offset: 0x7C9E7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8nativeGLs5Int64VvsTo', symObjAddr: 0x640, symBinAddr: 0x5620, symSize: 0x40 }
-  - { offsetInCU: 0x45E, offset: 0x7CA40, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13nativeContexts5Int64VvgTo', symObjAddr: 0x680, symBinAddr: 0x5660, symSize: 0x40 }
-  - { offsetInCU: 0x4B4, offset: 0x7CA96, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13nativeContexts5Int64VvsTo', symObjAddr: 0x6F0, symBinAddr: 0x56D0, symSize: 0x40 }
-  - { offsetInCU: 0x50D, offset: 0x7CAEF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15native2DContexts5Int64VvgTo', symObjAddr: 0x730, symBinAddr: 0x5710, symSize: 0x20 }
-  - { offsetInCU: 0x563, offset: 0x7CB45, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15native2DContexts5Int64VvsTo', symObjAddr: 0x750, symBinAddr: 0x5730, symSize: 0x20 }
-  - { offsetInCU: 0x5BC, offset: 0x7CB9E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7mtlViewSo7MTKViewCvgTo', symObjAddr: 0x770, symBinAddr: 0x5750, symSize: 0x20 }
-  - { offsetInCU: 0x614, offset: 0x7CBF6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7mtlViewSo7MTKViewCvsTo', symObjAddr: 0x790, symBinAddr: 0x5770, symSize: 0x30 }
-  - { offsetInCU: 0x66D, offset: 0x7CC4F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7glkViewAA0A7GLKViewCvgTo', symObjAddr: 0x7C0, symBinAddr: 0x57A0, symSize: 0x20 }
-  - { offsetInCU: 0x6C5, offset: 0x7CCA7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7glkViewAA0A7GLKViewCvsTo', symObjAddr: 0x7E0, symBinAddr: 0x57C0, symSize: 0x30 }
-  - { offsetInCU: 0x71E, offset: 0x7CD00, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC4is2DSbvgTo', symObjAddr: 0x810, symBinAddr: 0x57F0, symSize: 0x20 }
-  - { offsetInCU: 0x774, offset: 0x7CD56, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC4is2DSbvsTo', symObjAddr: 0x830, symBinAddr: 0x5810, symSize: 0x10 }
-  - { offsetInCU: 0x7CD, offset: 0x7CDAF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7isMetalSbvgTo', symObjAddr: 0x840, symBinAddr: 0x5820, symSize: 0x20 }
-  - { offsetInCU: 0x823, offset: 0x7CE05, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7isMetalSbvsTo', symObjAddr: 0x860, symBinAddr: 0x5840, symSize: 0x10 }
-  - { offsetInCU: 0x866, offset: 0x7CE48, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18drawingBufferWidthSivgTo', symObjAddr: 0x870, symBinAddr: 0x5850, symSize: 0x30 }
-  - { offsetInCU: 0x898, offset: 0x7CE7A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19drawingBufferHeightSivgTo', symObjAddr: 0x960, symBinAddr: 0x5940, symSize: 0x30 }
-  - { offsetInCU: 0x8E0, offset: 0x7CEC2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5widthSfvgTo', symObjAddr: 0xA50, symBinAddr: 0x5A30, symSize: 0x30 }
-  - { offsetInCU: 0x948, offset: 0x7CF2A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6heightSfvgTo', symObjAddr: 0xAB0, symBinAddr: 0x5A90, symSize: 0x30 }
-  - { offsetInCU: 0x9E7, offset: 0x7CFC9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11initContextyySS_S4bs5Int32VS5btFTo', symObjAddr: 0xB20, symBinAddr: 0x5B00, symSize: 0xD0 }
-  - { offsetInCU: 0xA96, offset: 0x7D078, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17initWebGPUContextyys5Int64VFTo', symObjAddr: 0xDA0, symBinAddr: 0x5D80, symSize: 0x30 }
-  - { offsetInCU: 0xB46, offset: 0x7D128, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC015initContextWithE10AttributesyySS_S4bs5Int32VS5btFTo', symObjAddr: 0x1760, symBinAddr: 0x6740, symSize: 0xD0 }
-  - { offsetInCU: 0xBB0, offset: 0x7D192, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15create2DContextys5Int64VSb_S3bs5Int32VS5bAHtFTo', symObjAddr: 0x1A70, symBinAddr: 0x6A50, symSize: 0x90 }
-  - { offsetInCU: 0xBED, offset: 0x7D1CF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11forceLayoutyy12CoreGraphics7CGFloatV_AGtFTo', symObjAddr: 0x1BF0, symBinAddr: 0x6BD0, symSize: 0x100 }
-  - { offsetInCU: 0xC6B, offset: 0x7D24D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8snapshotySo7UIImageCSgSbFTo', symObjAddr: 0x1DC0, symBinAddr: 0x6DA0, symSize: 0x40 }
-  - { offsetInCU: 0xC9E, offset: 0x7D280, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8rendererAA9NSCRenderCSgvgTo', symObjAddr: 0x1E00, symBinAddr: 0x6DE0, symSize: 0x20 }
-  - { offsetInCU: 0xCF8, offset: 0x7D2DA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8rendererAA9NSCRenderCSgvsTo', symObjAddr: 0x1E20, symBinAddr: 0x6E00, symSize: 0x30 }
-  - { offsetInCU: 0xD53, offset: 0x7D335, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6renderSbyFTo', symObjAddr: 0x1E90, symBinAddr: 0x6E70, symSize: 0x40 }
-  - { offsetInCU: 0xDE9, offset: 0x7D3CB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13context2DTestyys5Int64VFTo', symObjAddr: 0x1F10, symBinAddr: 0x6EF0, symSize: 0x60 }
-  - { offsetInCU: 0xEAE, offset: 0x7D490, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC22context2DTestToDataURLySSs5Int64VFTo', symObjAddr: 0x1FD0, symBinAddr: 0x6FB0, symSize: 0xA0 }
-  - { offsetInCU: 0xF3B, offset: 0x7D51D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC23enterBackgroundListeneryycSgvsTo', symObjAddr: 0x20C0, symBinAddr: 0x70A0, symSize: 0x70 }
-  - { offsetInCU: 0xF9D, offset: 0x7D57F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC20becomeActiveListeneryycSgvsTo', symObjAddr: 0x21D0, symBinAddr: 0x71B0, symSize: 0x70 }
-  - { offsetInCU: 0xFFA, offset: 0x7D5DC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvgTo', symObjAddr: 0x2240, symBinAddr: 0x7220, symSize: 0xB0 }
-  - { offsetInCU: 0x104A, offset: 0x7D62C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvsTo', symObjAddr: 0x23B0, symBinAddr: 0x7390, symSize: 0x90 }
-  - { offsetInCU: 0x10DA, offset: 0x7D6BC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5coderACSgSo7NSCoderC_tcfcTo', symObjAddr: 0x3160, symBinAddr: 0x8140, symSize: 0x30 }
-  - { offsetInCU: 0x112F, offset: 0x7D711, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5frameACSo6CGRectV_tcfcTo', symObjAddr: 0x3D20, symBinAddr: 0x8D00, symSize: 0x30 }
-  - { offsetInCU: 0x1162, offset: 0x7D744, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvgTo', symObjAddr: 0x3D50, symBinAddr: 0x8D30, symSize: 0x20 }
-  - { offsetInCU: 0x11BA, offset: 0x7D79C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvsTo', symObjAddr: 0x3D70, symBinAddr: 0x8D50, symSize: 0x30 }
-  - { offsetInCU: 0x1228, offset: 0x7D80A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13readyListenerAA0cE0_pSgvgTo', symObjAddr: 0x3E20, symBinAddr: 0x8E00, symSize: 0x30 }
-  - { offsetInCU: 0x1282, offset: 0x7D864, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13readyListenerAA0cE0_pSgvsTo', symObjAddr: 0x3E50, symBinAddr: 0x8E30, symSize: 0x30 }
-  - { offsetInCU: 0x12E2, offset: 0x7D8C4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11setListeneryyAA0cE0_pSgFTo', symObjAddr: 0x3EB0, symBinAddr: 0x8E90, symSize: 0x30 }
-  - { offsetInCU: 0x1426, offset: 0x7DA08, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC14layoutSubviewsyyFTo', symObjAddr: 0x4290, symBinAddr: 0x9270, symSize: 0x30 }
-  - { offsetInCU: 0x1459, offset: 0x7DA3B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCfDTo', symObjAddr: 0x45B0, symBinAddr: 0x9590, symSize: 0x20 }
-  - { offsetInCU: 0x1494, offset: 0x7DA76, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC21getBoundingClientRectyySo6UIViewC_SvtFZTo', symObjAddr: 0x46A0, symBinAddr: 0x9680, symSize: 0x30 }
-  - { offsetInCU: 0x14C7, offset: 0x7DAA9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC14shared_context33_508084857CA7D194CA72FEB80DD78002LLs5Int64VvgZTf4d_n', symObjAddr: 0x50D0, symBinAddr: 0xA0B0, symSize: 0x2A0 }
-  - { offsetInCU: 0x162F, offset: 0x7DC11, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC21getBoundingClientRectyySo6UIViewC_SvtFZTf4nnd_n', symObjAddr: 0x5440, symBinAddr: 0xA420, symSize: 0xC0 }
-  - { offsetInCU: 0x184B, offset: 0x7DE2D, size: 0x8, addend: 0x0, symName: '_$sIeg_IeyB_TR', symObjAddr: 0x2090, symBinAddr: 0x7070, symSize: 0x30 }
-  - { offsetInCU: 0x1863, offset: 0x7DE45, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_So8NSStringCABIeyByy_TR', symObjAddr: 0x2340, symBinAddr: 0x7320, symSize: 0x70 }
-  - { offsetInCU: 0x187B, offset: 0x7DE5D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvpACTK', symObjAddr: 0x24A0, symBinAddr: 0x7480, symSize: 0x90 }
-  - { offsetInCU: 0x18B3, offset: 0x7DE95, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvpACTk', symObjAddr: 0x2530, symBinAddr: 0x7510, symSize: 0xC0 }
-  - { offsetInCU: 0x18F3, offset: 0x7DED5, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCytIegnnr_SSABIeggg_TR', symObjAddr: 0x25F0, symBinAddr: 0x75D0, symSize: 0x70 }
-  - { offsetInCU: 0x19A3, offset: 0x7DF85, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCfETo', symObjAddr: 0x45D0, symBinAddr: 0x95B0, symSize: 0xC0 }
-  - { offsetInCU: 0x19D3, offset: 0x7DFB5, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_SgWOy', symObjAddr: 0x46D0, symBinAddr: 0x96B0, symSize: 0x20 }
-  - { offsetInCU: 0x19E7, offset: 0x7DFC9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCMa', symObjAddr: 0x46F0, symBinAddr: 0x96D0, symSize: 0x20 }
-  - { offsetInCU: 0x19FB, offset: 0x7DFDD, size: 0x8, addend: 0x0, symName: '_$ss29getContiguousArrayStorageType3fors01_bcD0CyxGmxm_tlFSo18NSLayoutConstraintC_Tgm5', symObjAddr: 0x4710, symBinAddr: 0x96F0, symSize: 0x60 }
-  - { offsetInCU: 0x1C02, offset: 0x7E1E4, size: 0x8, addend: 0x0, symName: ___swift_instantiateConcreteTypeFromMangledName, symObjAddr: 0x5370, symBinAddr: 0xA350, symSize: 0x40 }
-  - { offsetInCU: 0x1C16, offset: 0x7E1F8, size: 0x8, addend: 0x0, symName: '_$sypSgWOh', symObjAddr: 0x53B0, symBinAddr: 0xA390, symSize: 0x30 }
-  - { offsetInCU: 0x1C2A, offset: 0x7E20C, size: 0x8, addend: 0x0, symName: ___swift_project_boxed_opaque_existential_0, symObjAddr: 0x53E0, symBinAddr: 0xA3C0, symSize: 0x30 }
-  - { offsetInCU: 0x1C3E, offset: 0x7E220, size: 0x8, addend: 0x0, symName: ___swift_destroy_boxed_opaque_existential_0, symObjAddr: 0x5410, symBinAddr: 0xA3F0, symSize: 0x30 }
-  - { offsetInCU: 0x1C5D, offset: 0x7E23F, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSo19UIGestureRecognizerCIeyByy_SSADIeggg_TRTA', symObjAddr: 0x59A0, symBinAddr: 0xA980, symSize: 0x40 }
-  - { offsetInCU: 0x1C86, offset: 0x7E268, size: 0x8, addend: 0x0, symName: _block_copy_helper, symObjAddr: 0x59E0, symBinAddr: 0xA9C0, symSize: 0x20 }
-  - { offsetInCU: 0x1C9A, offset: 0x7E27C, size: 0x8, addend: 0x0, symName: _block_destroy_helper, symObjAddr: 0x5A00, symBinAddr: 0xA9E0, symSize: 0x10 }
-  - { offsetInCU: 0x1CAE, offset: 0x7E290, size: 0x8, addend: 0x0, symName: '_$sIeg_SgWOe', symObjAddr: 0x5A10, symBinAddr: 0xA9F0, symSize: 0x20 }
-  - { offsetInCU: 0x1CCD, offset: 0x7E2AF, size: 0x8, addend: 0x0, symName: '_$sIeyB_Ieg_TRTA', symObjAddr: 0x5A30, symBinAddr: 0xAA10, symSize: 0x10 }
-  - { offsetInCU: 0x1CF6, offset: 0x7E2D8, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCytIegnnr_SSABIeggg_TRTA', symObjAddr: 0x5A60, symBinAddr: 0xAA40, symSize: 0x20 }
-  - { offsetInCU: 0x1D15, offset: 0x7E2F7, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_SSABytIegnnr_TRTA', symObjAddr: 0x5A80, symBinAddr: 0xAA60, symSize: 0x30 }
-  - { offsetInCU: 0x1D3E, offset: 0x7E320, size: 0x8, addend: 0x0, symName: '_$sypWOb', symObjAddr: 0x5AB0, symBinAddr: 0xAA90, symSize: 0x20 }
-  - { offsetInCU: 0x1D52, offset: 0x7E334, size: 0x8, addend: 0x0, symName: '_$sypWOc', symObjAddr: 0x5B00, symBinAddr: 0xAAE0, symSize: 0x30 }
-  - { offsetInCU: 0x1FD7, offset: 0x7E5B9, size: 0x8, addend: 0x0, symName: '_$sSD17dictionaryLiteralSDyxq_Gx_q_td_tcfCSS_ypTgm5Tf4g_n', symObjAddr: 0x4FE0, symBinAddr: 0x9FC0, symSize: 0xF0 }
-  - { offsetInCU: 0x2469, offset: 0x7EA4B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvg', symObjAddr: 0x360, symBinAddr: 0x5340, symSize: 0x30 }
-  - { offsetInCU: 0x249A, offset: 0x7EA7C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvs', symObjAddr: 0x3C0, symBinAddr: 0x53A0, symSize: 0xE0 }
-  - { offsetInCU: 0x24E4, offset: 0x7EAC6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvM', symObjAddr: 0x4A0, symBinAddr: 0x5480, symSize: 0x50 }
-  - { offsetInCU: 0x2507, offset: 0x7EAE9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvM.resume.0', symObjAddr: 0x4F0, symBinAddr: 0x54D0, symSize: 0xE0 }
-  - { offsetInCU: 0x2548, offset: 0x7EB2A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8nativeGLs5Int64Vvg', symObjAddr: 0x610, symBinAddr: 0x55F0, symSize: 0x30 }
-  - { offsetInCU: 0x259E, offset: 0x7EB80, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13nativeContexts5Int64Vvg', symObjAddr: 0x6C0, symBinAddr: 0x56A0, symSize: 0x30 }
-  - { offsetInCU: 0x270A, offset: 0x7ECEC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18drawingBufferWidthSivg', symObjAddr: 0x8A0, symBinAddr: 0x5880, symSize: 0xC0 }
-  - { offsetInCU: 0x282F, offset: 0x7EE11, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19drawingBufferHeightSivg', symObjAddr: 0x990, symBinAddr: 0x5970, symSize: 0xC0 }
-  - { offsetInCU: 0x2975, offset: 0x7EF57, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5widthSfvg', symObjAddr: 0xA80, symBinAddr: 0x5A60, symSize: 0x30 }
-  - { offsetInCU: 0x29BB, offset: 0x7EF9D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6heightSfvg', symObjAddr: 0xAE0, symBinAddr: 0x5AC0, symSize: 0x30 }
-  - { offsetInCU: 0x29ED, offset: 0x7EFCF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11initContextyySS_S4bs5Int32VS5btF', symObjAddr: 0xB10, symBinAddr: 0x5AF0, symSize: 0x10 }
-  - { offsetInCU: 0x2B6A, offset: 0x7F14C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17initWebGPUContextyys5Int64VF', symObjAddr: 0xBF0, symBinAddr: 0x5BD0, symSize: 0x1B0 }
-  - { offsetInCU: 0x2F4D, offset: 0x7F52F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC015initContextWithE10AttributesyySS_S4bs5Int32VS5btF', symObjAddr: 0xDD0, symBinAddr: 0x5DB0, symSize: 0x990 }
-  - { offsetInCU: 0x36DB, offset: 0x7FCBD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15create2DContextys5Int64VSb_S3bs5Int32VS5bAHtF', symObjAddr: 0x1830, symBinAddr: 0x6810, symSize: 0x240 }
-  - { offsetInCU: 0x3B67, offset: 0x80149, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11forceLayoutyy12CoreGraphics7CGFloatV_AGtF', symObjAddr: 0x1B00, symBinAddr: 0x6AE0, symSize: 0xF0 }
-  - { offsetInCU: 0x3BF6, offset: 0x801D8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8snapshotySo7UIImageCSgSbF', symObjAddr: 0x1CF0, symBinAddr: 0x6CD0, symSize: 0xD0 }
-  - { offsetInCU: 0x3D4F, offset: 0x80331, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6renderSbyF', symObjAddr: 0x1E50, symBinAddr: 0x6E30, symSize: 0x40 }
-  - { offsetInCU: 0x3DD3, offset: 0x803B5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13context2DTestyys5Int64VF', symObjAddr: 0x1ED0, symBinAddr: 0x6EB0, symSize: 0x40 }
-  - { offsetInCU: 0x3EF2, offset: 0x804D4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC22context2DTestToDataURLySSs5Int64VF', symObjAddr: 0x1F70, symBinAddr: 0x6F50, symSize: 0x60 }
-  - { offsetInCU: 0x3FE8, offset: 0x805CA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvg', symObjAddr: 0x22F0, symBinAddr: 0x72D0, symSize: 0x50 }
-  - { offsetInCU: 0x4032, offset: 0x80614, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvs', symObjAddr: 0x2440, symBinAddr: 0x7420, symSize: 0x60 }
-  - { offsetInCU: 0x4059, offset: 0x8063B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvM', symObjAddr: 0x2660, symBinAddr: 0x7640, symSize: 0x40 }
-  - { offsetInCU: 0x407F, offset: 0x80661, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvM.resume.0', symObjAddr: 0x26A0, symBinAddr: 0x7680, symSize: 0x10 }
-  - { offsetInCU: 0x4141, offset: 0x80723, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5coderACSgSo7NSCoderC_tcfc', symObjAddr: 0x26B0, symBinAddr: 0x7690, symSize: 0xAB0 }
-  - { offsetInCU: 0x4366, offset: 0x80948, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5frameACSo6CGRectV_tcfC', symObjAddr: 0x3190, symBinAddr: 0x8170, symSize: 0x80 }
-  - { offsetInCU: 0x438F, offset: 0x80971, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5frameACSo6CGRectV_tcfc', symObjAddr: 0x3210, symBinAddr: 0x81F0, symSize: 0xB10 }
-  - { offsetInCU: 0x45D5, offset: 0x80BB7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvW', symObjAddr: 0x3DA0, symBinAddr: 0x8D80, symSize: 0x80 }
-  - { offsetInCU: 0x46CB, offset: 0x80CAD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11setListeneryyAA0cE0_pSgF', symObjAddr: 0x3E80, symBinAddr: 0x8E60, symSize: 0x30 }
-  - { offsetInCU: 0x4767, offset: 0x80D49, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6resize33_508084857CA7D194CA72FEB80DD78002LLyyF', symObjAddr: 0x3EE0, symBinAddr: 0x8EC0, symSize: 0x110 }
-  - { offsetInCU: 0x49B8, offset: 0x80F9A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC14layoutSubviewsyyF', symObjAddr: 0x3FF0, symBinAddr: 0x8FD0, symSize: 0x2A0 }
-  - { offsetInCU: 0x4C14, offset: 0x811F6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCfD', symObjAddr: 0x42C0, symBinAddr: 0x92A0, symSize: 0x2F0 }
-  - { offsetInCU: 0x4CA2, offset: 0x81284, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC21getBoundingClientRectyySo6UIViewC_SvtFZ', symObjAddr: 0x4690, symBinAddr: 0x9670, symSize: 0x10 }
-  - { offsetInCU: 0x4CCA, offset: 0x812AC, size: 0x8, addend: 0x0, symName: '_$ss22__RawDictionaryStorageC4findys10_HashTableV6BucketV6bucket_Sb5foundtxSHRzlFSS_Tg5', symObjAddr: 0x4770, symBinAddr: 0x9750, symSize: 0x60 }
-  - { offsetInCU: 0x4D24, offset: 0x81306, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV7_insert2at3key5valueys10_HashTableV6BucketV_xnq_ntFSS_ypTg5', symObjAddr: 0x47D0, symBinAddr: 0x97B0, symSize: 0x60 }
-  - { offsetInCU: 0x4D90, offset: 0x81372, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV12mutatingFind_8isUniques10_HashTableV6BucketV6bucket_Sb5foundtx_SbtFSS_ypTg5', symObjAddr: 0x4830, symBinAddr: 0x9810, symSize: 0xB0 }
-  - { offsetInCU: 0x4DCD, offset: 0x813AF, size: 0x8, addend: 0x0, symName: '_$ss22__RawDictionaryStorageC4find_9hashValues10_HashTableV6BucketV6bucket_Sb5foundtx_SitSHRzlFSS_Tg5', symObjAddr: 0x48E0, symBinAddr: 0x98C0, symSize: 0xE0 }
-  - { offsetInCU: 0x4E38, offset: 0x8141A, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV4copyyyFSS_ypTg5', symObjAddr: 0x49C0, symBinAddr: 0x99A0, symSize: 0x260 }
-  - { offsetInCU: 0x4EE0, offset: 0x814C2, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV20_copyOrMoveAndResize8capacity12moveElementsySi_SbtFSS_ypTg5', symObjAddr: 0x4C20, symBinAddr: 0x9C00, symSize: 0x3C0 }
-  - { offsetInCU: 0x27, offset: 0x81716, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative7GLUtilsCfD', symObjAddr: 0x0, symBinAddr: 0xABC0, symSize: 0x20 }
-  - { offsetInCU: 0x62, offset: 0x81751, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative7GLUtilsCMa', symObjAddr: 0x20, symBinAddr: 0xABE0, symSize: 0x14 }
-  - { offsetInCU: 0x1AF, offset: 0x8189E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative7GLUtilsCfD', symObjAddr: 0x0, symBinAddr: 0xABC0, symSize: 0x20 }
-  - { offsetInCU: 0x65, offset: 0x8192B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8mPrograms6UInt32VvgTo', symObjAddr: 0x0, symBinAddr: 0xAC00, symSize: 0x10 }
-  - { offsetInCU: 0xBB, offset: 0x81981, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8mPrograms6UInt32VvsTo', symObjAddr: 0x10, symBinAddr: 0xAC10, symSize: 0x10 }
-  - { offsetInCU: 0x114, offset: 0x819DA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3rbos6UInt32VvgTo', symObjAddr: 0x20, symBinAddr: 0xAC20, symSize: 0x40 }
-  - { offsetInCU: 0x16A, offset: 0x81A30, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3rbos6UInt32VvsTo', symObjAddr: 0x60, symBinAddr: 0xAC60, symSize: 0x40 }
-  - { offsetInCU: 0x1C3, offset: 0x81A89, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3fbos6UInt32VvgTo', symObjAddr: 0xA0, symBinAddr: 0xACA0, symSize: 0x40 }
-  - { offsetInCU: 0x219, offset: 0x81ADF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3fbos6UInt32VvsTo', symObjAddr: 0xE0, symBinAddr: 0xACE0, symSize: 0x40 }
-  - { offsetInCU: 0x272, offset: 0x81B38, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC5widthSivgTo', symObjAddr: 0x120, symBinAddr: 0xAD20, symSize: 0x20 }
-  - { offsetInCU: 0x2C8, offset: 0x81B8E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC5widthSivsTo', symObjAddr: 0x140, symBinAddr: 0xAD40, symSize: 0x20 }
-  - { offsetInCU: 0x321, offset: 0x81BE7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC6heightSivgTo', symObjAddr: 0x160, symBinAddr: 0xAD60, symSize: 0x20 }
-  - { offsetInCU: 0x377, offset: 0x81C3D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC6heightSivsTo', symObjAddr: 0x180, symBinAddr: 0xAD80, symSize: 0x20 }
-  - { offsetInCU: 0x3D0, offset: 0x81C96, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC2abs6UInt32VvgTo', symObjAddr: 0x1A0, symBinAddr: 0xADA0, symSize: 0x40 }
-  - { offsetInCU: 0x426, offset: 0x81CEC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC2abs6UInt32VvsTo', symObjAddr: 0x1E0, symBinAddr: 0xADE0, symSize: 0x40 }
-  - { offsetInCU: 0x47F, offset: 0x81D45, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3poss5Int32VvgTo', symObjAddr: 0x220, symBinAddr: 0xAE20, symSize: 0x10 }
-  - { offsetInCU: 0x4D5, offset: 0x81D9B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3poss5Int32VvsTo', symObjAddr: 0x230, symBinAddr: 0xAE30, symSize: 0x10 }
-  - { offsetInCU: 0x52E, offset: 0x81DF4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10samplerPoss5Int32VvgTo', symObjAddr: 0x240, symBinAddr: 0xAE40, symSize: 0x10 }
-  - { offsetInCU: 0x584, offset: 0x81E4A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10samplerPoss5Int32VvsTo', symObjAddr: 0x250, symBinAddr: 0xAE50, symSize: 0x10 }
-  - { offsetInCU: 0x5DD, offset: 0x81EA3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9vextexBufSaySfGvgTo', symObjAddr: 0x260, symBinAddr: 0xAE60, symSize: 0x40 }
-  - { offsetInCU: 0x633, offset: 0x81EF9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9vextexBufSaySfGvsTo', symObjAddr: 0x2A0, symBinAddr: 0xAEA0, symSize: 0x40 }
-  - { offsetInCU: 0x676, offset: 0x81F3C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13SIZE_OF_FLOATSivgZTo', symObjAddr: 0x2E0, symBinAddr: 0xAEE0, symSize: 0x10 }
-  - { offsetInCU: 0x692, offset: 0x81F58, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13VERTEX_SHADERSSvgZTo', symObjAddr: 0x2F0, symBinAddr: 0xAEF0, symSize: 0x30 }
-  - { offsetInCU: 0x6C4, offset: 0x81F8A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7surfaceSo9IOSurfaceCSgvgTo', symObjAddr: 0x320, symBinAddr: 0xAF20, symSize: 0x20 }
-  - { offsetInCU: 0x71C, offset: 0x81FE2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7surfaceSo9IOSurfaceCSgvsTo', symObjAddr: 0x340, symBinAddr: 0xAF40, symSize: 0x30 }
-  - { offsetInCU: 0x775, offset: 0x8203B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8pixelBufs9UnmanagedVySo11CVBufferRefaGSgvgTo', symObjAddr: 0x490, symBinAddr: 0xB090, symSize: 0x20 }
-  - { offsetInCU: 0x7CB, offset: 0x82091, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8pixelBufs9UnmanagedVySo11CVBufferRefaGSgvsTo', symObjAddr: 0x4B0, symBinAddr: 0xB0B0, symSize: 0x20 }
-  - { offsetInCU: 0x83A, offset: 0x82100, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCACycfcTo', symObjAddr: 0x680, symBinAddr: 0xB240, symSize: 0x20 }
-  - { offsetInCU: 0x86C, offset: 0x82132, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7destroyyyFTo', symObjAddr: 0x7E0, symBinAddr: 0xB3A0, symSize: 0x30 }
-  - { offsetInCU: 0x8C4, offset: 0x8218A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10texImage2Dyys5Int32V_A4fA9NSCCanvasCAHSbtFTo', symObjAddr: 0x830, symBinAddr: 0xB3F0, symSize: 0x80 }
-  - { offsetInCU: 0x928, offset: 0x821EE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9drawFrame6buffer5width6height14internalFormat6format10flipYWebGLySo11CVBufferRefa_S2is5Int32VANSbtFTo', symObjAddr: 0x8B0, symBinAddr: 0xB470, symSize: 0x80 }
-  - { offsetInCU: 0x9CA, offset: 0x82290, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13createSurfaceyyFTo', symObjAddr: 0xCE0, symBinAddr: 0xB8A0, symSize: 0x30 }
-  - { offsetInCU: 0xAB4, offset: 0x8237A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCMa', symObjAddr: 0x660, symBinAddr: 0xB220, symSize: 0x20 }
-  - { offsetInCU: 0xB33, offset: 0x823F9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCfETo', symObjAddr: 0xD40, symBinAddr: 0xB900, symSize: 0x60 }
-  - { offsetInCU: 0x1271, offset: 0x82B37, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCACycfC', symObjAddr: 0x4D0, symBinAddr: 0xB0D0, symSize: 0x20 }
-  - { offsetInCU: 0x128B, offset: 0x82B51, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCACycfc', symObjAddr: 0x4F0, symBinAddr: 0xB0F0, symSize: 0x130 }
-  - { offsetInCU: 0x12BB, offset: 0x82B81, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7destroyyyF', symObjAddr: 0x6A0, symBinAddr: 0xB260, symSize: 0x140 }
-  - { offsetInCU: 0x1474, offset: 0x82D3A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10texImage2Dyys5Int32V_A4fA9NSCCanvasCAHSbtF', symObjAddr: 0x810, symBinAddr: 0xB3D0, symSize: 0x20 }
-  - { offsetInCU: 0x1525, offset: 0x82DEB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13createSurfaceyyF', symObjAddr: 0x930, symBinAddr: 0xB4F0, symSize: 0x3B0 }
-  - { offsetInCU: 0x18BB, offset: 0x83181, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCfD', symObjAddr: 0xD10, symBinAddr: 0xB8D0, symSize: 0x30 }
-  - { offsetInCU: 0x19B4, offset: 0x8327A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10texImage2Dyys5Int32V_A4fA9NSCCanvasCAHSbtFTf4ddnndnndn_n', symObjAddr: 0xDA0, symBinAddr: 0xB960, symSize: 0x720 }
-  - { offsetInCU: 0x231C, offset: 0x83BE2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9drawFrame6buffer5width6height14internalFormat6format10flipYWebGLySo11CVBufferRefa_S2is5Int32VANSbtFTf4nnnnndn_n', symObjAddr: 0x1520, symBinAddr: 0xC0E0, symSize: 0x7EC }
-  - { offsetInCU: 0x10C, offset: 0x8478B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC6target6actionAEypSg_10ObjectiveC8SelectorVSgtcfcTo', symObjAddr: 0x1120, symBinAddr: 0xD9B0, symSize: 0x60 }
-  - { offsetInCU: 0x19C, offset: 0x8481B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerCfETo', symObjAddr: 0x11A0, symBinAddr: 0xDA30, symSize: 0x20 }
-  - { offsetInCU: 0x1CB, offset: 0x8484A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC6handleyySo19UIGestureRecognizerCFTo', symObjAddr: 0x11C0, symBinAddr: 0xDA50, symSize: 0x10 }
-  - { offsetInCU: 0x368, offset: 0x849E7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerCACycfcTo', symObjAddr: 0x1A40, symBinAddr: 0xE2D0, symSize: 0x30 }
-  - { offsetInCU: 0x5E4, offset: 0x84C63, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerCfETo', symObjAddr: 0x1AC0, symBinAddr: 0xE350, symSize: 0x60 }
-  - { offsetInCU: 0x613, offset: 0x84C92, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerCMa', symObjAddr: 0x1B20, symBinAddr: 0xE3B0, symSize: 0x20 }
-  - { offsetInCU: 0x627, offset: 0x84CA6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerCMa', symObjAddr: 0x1B40, symBinAddr: 0xE3D0, symSize: 0x20 }
-  - { offsetInCU: 0x63B, offset: 0x84CBA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwCP', symObjAddr: 0x1B60, symBinAddr: 0xE3F0, symSize: 0x30 }
-  - { offsetInCU: 0x64F, offset: 0x84CCE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwxx', symObjAddr: 0x1B90, symBinAddr: 0xE420, symSize: 0x10 }
-  - { offsetInCU: 0x663, offset: 0x84CE2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwcp', symObjAddr: 0x1BA0, symBinAddr: 0xE430, symSize: 0x30 }
-  - { offsetInCU: 0x677, offset: 0x84CF6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwca', symObjAddr: 0x1BD0, symBinAddr: 0xE460, symSize: 0x50 }
-  - { offsetInCU: 0x68B, offset: 0x84D0A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwta', symObjAddr: 0x1C40, symBinAddr: 0xE4B0, symSize: 0x40 }
-  - { offsetInCU: 0x69F, offset: 0x84D1E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwet', symObjAddr: 0x1C80, symBinAddr: 0xE4F0, symSize: 0x40 }
-  - { offsetInCU: 0x6B3, offset: 0x84D32, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwst', symObjAddr: 0x1CC0, symBinAddr: 0xE530, symSize: 0x50 }
-  - { offsetInCU: 0x6C7, offset: 0x84D46, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVMa', symObjAddr: 0x1D10, symBinAddr: 0xE580, symSize: 0x10 }
-  - { offsetInCU: 0x6DB, offset: 0x84D5A, size: 0x8, addend: 0x0, symName: '_$sypSgWOc', symObjAddr: 0x1D20, symBinAddr: 0xE590, symSize: 0x40 }
-  - { offsetInCU: 0x6EF, offset: 0x84D6E, size: 0x8, addend: 0x0, symName: '_$sSo7UITouchCSo8NSObjectCSH10ObjectiveCWl', symObjAddr: 0x1E30, symBinAddr: 0xE5D0, symSize: 0x50 }
-  - { offsetInCU: 0x703, offset: 0x84D82, size: 0x8, addend: 0x0, symName: '_$sSh8IteratorV8_VariantOyx__GSHRzlWOe', symObjAddr: 0x1E80, symBinAddr: 0xE620, symSize: 0x20 }
-  - { offsetInCU: 0x761, offset: 0x84DE0, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_SgWOe', symObjAddr: 0x21A0, symBinAddr: 0xE940, symSize: 0x14 }
-  - { offsetInCU: 0xCB4, offset: 0x85333, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC12touchesBegan_4withyShySo7UITouchCG_So7UIEventCtF', symObjAddr: 0x0, symBinAddr: 0xC8D0, symSize: 0x630 }
-  - { offsetInCU: 0xF39, offset: 0x855B8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC12touchesMoved_4withyShySo7UITouchCG_So7UIEventCtF', symObjAddr: 0x650, symBinAddr: 0xCF20, symSize: 0xE0 }
-  - { offsetInCU: 0xFB8, offset: 0x85637, size: 0x8, addend: 0x0, symName: '_$sSa6remove2atxSi_tF12CanvasNative15NSCTouchHandlerC7PointerV_Tg5', symObjAddr: 0x800, symBinAddr: 0xD0B0, symSize: 0xB0 }
-  - { offsetInCU: 0x102A, offset: 0x856A9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC6target6actionAEypSg_10ObjectiveC8SelectorVSgtcfc', symObjAddr: 0x1030, symBinAddr: 0xD8C0, symSize: 0xF0 }
-  - { offsetInCU: 0x1179, offset: 0x857F8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC6onMove33_044DDF836BDB3B89B481C6F58BB6EF6BLLyySo19UIGestureRecognizerC_ShySo7UITouchCGSgtF', symObjAddr: 0x1590, symBinAddr: 0xDE20, symSize: 0x4B0 }
-  - { offsetInCU: 0x18C2, offset: 0x85F41, size: 0x8, addend: 0x0, symName: '_$ss12_ArrayBufferV20_consumeAndCreateNewAByxGyF12CanvasNative15NSCTouchHandlerC7PointerV_Tg5', symObjAddr: 0x1EA0, symBinAddr: 0xE640, symSize: 0x20 }
-  - { offsetInCU: 0x195A, offset: 0x85FD9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC6canvasAcA9NSCCanvasC_tcfcTf4gn_n', symObjAddr: 0x1EC0, symBinAddr: 0xE660, symSize: 0x1F0 }
-  - { offsetInCU: 0x27, offset: 0x861A2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC14FAILED_TO_LOADSSvgZTo', symObjAddr: 0x0, symBinAddr: 0xE960, symSize: 0x30 }
-  - { offsetInCU: 0x4B, offset: 0x861C6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queueSo012OS_dispatch_E0CvpZ', symObjAddr: 0x2A0, symBinAddr: 0x12D31C8, symSize: 0x0 }
-  - { offsetInCU: 0x65, offset: 0x861E0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC14FAILED_TO_LOADSSvgZTo', symObjAddr: 0x0, symBinAddr: 0xE960, symSize: 0x30 }
-  - { offsetInCU: 0x98, offset: 0x86213, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queueSo012OS_dispatch_E0CvgZTo', symObjAddr: 0x160, symBinAddr: 0xEAC0, symSize: 0x30 }
-  - { offsetInCU: 0x104, offset: 0x8627F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCACycfcTo', symObjAddr: 0x200, symBinAddr: 0xEB60, symSize: 0x30 }
-  - { offsetInCU: 0x158, offset: 0x862D3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queue_WZ', symObjAddr: 0x30, symBinAddr: 0xE990, symSize: 0xF0 }
-  - { offsetInCU: 0x183, offset: 0x862FE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCMa', symObjAddr: 0x1E0, symBinAddr: 0xEB40, symSize: 0x20 }
-  - { offsetInCU: 0x197, offset: 0x86312, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCfETo', symObjAddr: 0x260, symBinAddr: 0xEBC0, symSize: 0x10 }
-  - { offsetInCU: 0x1C2, offset: 0x8633D, size: 0x8, addend: 0x0, symName: '_$sSo17OS_dispatch_queueCMa', symObjAddr: 0x270, symBinAddr: 0xEBD0, symSize: 0x2F }
-  - { offsetInCU: 0x34A, offset: 0x864C5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queueSo012OS_dispatch_E0CvgZ', symObjAddr: 0x120, symBinAddr: 0xEA80, symSize: 0x40 }
-  - { offsetInCU: 0x38A, offset: 0x86505, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCACycfC', symObjAddr: 0x190, symBinAddr: 0xEAF0, symSize: 0x20 }
-  - { offsetInCU: 0x39E, offset: 0x86519, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCACycfc', symObjAddr: 0x1B0, symBinAddr: 0xEB10, symSize: 0x30 }
-  - { offsetInCU: 0x3DA, offset: 0x86555, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCfD', symObjAddr: 0x230, symBinAddr: 0xEB90, symSize: 0x30 }
-  - { offsetInCU: 0x2B, offset: 0x865A3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC18createTextureCacheSo017CVOpenGLESTextureF3RefaSgyFZ', symObjAddr: 0x0, symBinAddr: 0xEC00, symSize: 0xA0 }
-  - { offsetInCU: 0x66, offset: 0x865DE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC18createTextureCacheSo017CVOpenGLESTextureF3RefaSgyFZTo', symObjAddr: 0xA0, symBinAddr: 0xECA0, symSize: 0xA0 }
-  - { offsetInCU: 0xF9, offset: 0x86671, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11createImageySo11CVBufferRefaSgSo022CVOpenGLESTextureCacheG0a_AFSo012CFDictionaryG0aSgs6UInt32Vs5Int32VA2p2NSitFZTo', symObjAddr: 0x1D0, symBinAddr: 0xEDD0, symSize: 0x100 }
-  - { offsetInCU: 0x1AD, offset: 0x86725, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11setupRenderAA9NSCRenderCyFZTo', symObjAddr: 0x300, symBinAddr: 0xEF00, symSize: 0x30 }
-  - { offsetInCU: 0x22D, offset: 0x867A5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC9drawFrameyySo8AVPlayerC_So0F15ItemVideoOutputCSo6CGSizeVAA9NSCRenderCs5Int32VANSbtFZTo', symObjAddr: 0x340, symBinAddr: 0xEF40, symSize: 0x90 }
-  - { offsetInCU: 0x2A6, offset: 0x8681E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11writeToFileyySo6NSDataC_SStKFZTo', symObjAddr: 0x4E0, symBinAddr: 0xF0E0, symSize: 0x140 }
-  - { offsetInCU: 0x345, offset: 0x868BD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCACycfcTo', symObjAddr: 0x670, symBinAddr: 0xF270, symSize: 0x30 }
-  - { offsetInCU: 0x398, offset: 0x86910, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC9drawFrameyySo8AVPlayerC_So0F15ItemVideoOutputCSo6CGSizeVAA9NSCRenderCs5Int32VANSbtFZTf4nnnnnndd_n', symObjAddr: 0x6D0, symBinAddr: 0xF2D0, symSize: 0x170 }
-  - { offsetInCU: 0x50B, offset: 0x86A83, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC7getFile33_F00B23A4165DD6ABFCD23C8811C7DF43LLyS2SKFZTf4nd_g', symObjAddr: 0x840, symBinAddr: 0xF440, symSize: 0x310 }
-  - { offsetInCU: 0x5EA, offset: 0x86B62, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCMa', symObjAddr: 0xB50, symBinAddr: 0xF750, symSize: 0x20 }
-  - { offsetInCU: 0x5FE, offset: 0x86B76, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOAEs5ErrorAAWl', symObjAddr: 0xB70, symBinAddr: 0xF770, symSize: 0x30 }
-  - { offsetInCU: 0x612, offset: 0x86B8A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwCP', symObjAddr: 0xBA0, symBinAddr: 0xF7A0, symSize: 0x30 }
-  - { offsetInCU: 0x626, offset: 0x86B9E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwxx', symObjAddr: 0xBD0, symBinAddr: 0xF7D0, symSize: 0x10 }
-  - { offsetInCU: 0x63A, offset: 0x86BB2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwca', symObjAddr: 0xBE0, symBinAddr: 0xF7E0, symSize: 0x40 }
-  - { offsetInCU: 0x64E, offset: 0x86BC6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwta', symObjAddr: 0xC30, symBinAddr: 0xF820, symSize: 0x30 }
-  - { offsetInCU: 0x662, offset: 0x86BDA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwet', symObjAddr: 0xC60, symBinAddr: 0xF850, symSize: 0x40 }
-  - { offsetInCU: 0x676, offset: 0x86BEE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwst', symObjAddr: 0xCA0, symBinAddr: 0xF890, symSize: 0x40 }
-  - { offsetInCU: 0x68A, offset: 0x86C02, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwug', symObjAddr: 0xCE0, symBinAddr: 0xF8D0, symSize: 0x10 }
-  - { offsetInCU: 0x69E, offset: 0x86C16, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwup', symObjAddr: 0xCF0, symBinAddr: 0xF8E0, symSize: 0x10 }
-  - { offsetInCU: 0x6B2, offset: 0x86C2A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwui', symObjAddr: 0xD00, symBinAddr: 0xF8F0, symSize: 0x10 }
-  - { offsetInCU: 0x6C6, offset: 0x86C3E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOMa', symObjAddr: 0xD10, symBinAddr: 0xF900, symSize: 0x10 }
-  - { offsetInCU: 0x74E, offset: 0x86CC6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP7_domainSSvgTW', symObjAddr: 0x3D0, symBinAddr: 0xEFD0, symSize: 0x10 }
-  - { offsetInCU: 0x76A, offset: 0x86CE2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP5_codeSivgTW', symObjAddr: 0x3E0, symBinAddr: 0xEFE0, symSize: 0x10 }
-  - { offsetInCU: 0x786, offset: 0x86CFE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP9_userInfoyXlSgvgTW', symObjAddr: 0x3F0, symBinAddr: 0xEFF0, symSize: 0x10 }
-  - { offsetInCU: 0x7A2, offset: 0x86D1A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP19_getEmbeddedNSErroryXlSgyFTW', symObjAddr: 0x400, symBinAddr: 0xF000, symSize: 0x10 }
-  - { offsetInCU: 0xA56, offset: 0x86FCE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC18createTextureCacheSo017CVOpenGLESTextureF3RefaSgyFZ', symObjAddr: 0x0, symBinAddr: 0xEC00, symSize: 0xA0 }
-  - { offsetInCU: 0xAEC, offset: 0x87064, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11createImageySo11CVBufferRefaSgSo022CVOpenGLESTextureCacheG0a_AFSo012CFDictionaryG0aSgs6UInt32Vs5Int32VA2p2NSitFZ', symObjAddr: 0x140, symBinAddr: 0xED40, symSize: 0x90 }
-  - { offsetInCU: 0xC71, offset: 0x871E9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11setupRenderAA9NSCRenderCyFZ', symObjAddr: 0x2D0, symBinAddr: 0xEED0, symSize: 0x30 }
-  - { offsetInCU: 0xCBB, offset: 0x87233, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC9drawFrameyySo8AVPlayerC_So0F15ItemVideoOutputCSo6CGSizeVAA9NSCRenderCs5Int32VANSbtFZ', symObjAddr: 0x330, symBinAddr: 0xEF30, symSize: 0x10 }
-  - { offsetInCU: 0xCDD, offset: 0x87255, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11writeToFileyySo6NSDataC_SStKFZ', symObjAddr: 0x410, symBinAddr: 0xF010, symSize: 0xD0 }
-  - { offsetInCU: 0xD8D, offset: 0x87305, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCACycfC', symObjAddr: 0x620, symBinAddr: 0xF220, symSize: 0x20 }
-  - { offsetInCU: 0xDA1, offset: 0x87319, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCACycfc', symObjAddr: 0x640, symBinAddr: 0xF240, symSize: 0x30 }
-  - { offsetInCU: 0xDD7, offset: 0x8734F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCfD', symObjAddr: 0x6A0, symBinAddr: 0xF2A0, symSize: 0x30 }
-  - { offsetInCU: 0x27, offset: 0x8746F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x0, symBinAddr: 0xF920, symSize: 0x10 }
-  - { offsetInCU: 0x71, offset: 0x874B9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZTo', symObjAddr: 0x10, symBinAddr: 0xF930, symSize: 0x60 }
-  - { offsetInCU: 0xF6, offset: 0x8753E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS2ftFZTo', symObjAddr: 0x80, symBinAddr: 0xF9A0, symSize: 0x50 }
-  - { offsetInCU: 0x193, offset: 0x875DB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS4ftFZTo', symObjAddr: 0xE0, symBinAddr: 0xFA00, symSize: 0x60 }
-  - { offsetInCU: 0x25C, offset: 0x876A4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS8ftFZTo', symObjAddr: 0x150, symBinAddr: 0xFA70, symSize: 0x90 }
-  - { offsetInCU: 0x339, offset: 0x87781, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCACycfcTo', symObjAddr: 0x230, symBinAddr: 0xFB50, symSize: 0x30 }
-  - { offsetInCU: 0x38D, offset: 0x877D5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCMa', symObjAddr: 0x290, symBinAddr: 0xFBB0, symSize: 0x14 }
-  - { offsetInCU: 0x4FD, offset: 0x87945, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x0, symBinAddr: 0xF920, symSize: 0x10 }
-  - { offsetInCU: 0x5A0, offset: 0x879E8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS2ftFZ', symObjAddr: 0x70, symBinAddr: 0xF990, symSize: 0x10 }
-  - { offsetInCU: 0x640, offset: 0x87A88, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS4ftFZ', symObjAddr: 0xD0, symBinAddr: 0xF9F0, symSize: 0x10 }
-  - { offsetInCU: 0x703, offset: 0x87B4B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS8ftFZ', symObjAddr: 0x140, symBinAddr: 0xFA60, symSize: 0x10 }
-  - { offsetInCU: 0x80F, offset: 0x87C57, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCACycfC', symObjAddr: 0x1E0, symBinAddr: 0xFB00, symSize: 0x20 }
-  - { offsetInCU: 0x823, offset: 0x87C6B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCACycfc', symObjAddr: 0x200, symBinAddr: 0xFB20, symSize: 0x30 }
-  - { offsetInCU: 0x859, offset: 0x87CA1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCfD', symObjAddr: 0x260, symBinAddr: 0xFB80, symSize: 0x30 }
-  - { offsetInCU: 0x27, offset: 0x87CEB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC10texImage2Dyys5Int64V_s5Int32VA4HSpys5UInt8VGSuSo6CGSizeVSbtFZ', symObjAddr: 0x0, symBinAddr: 0xFBD0, symSize: 0x30 }
-  - { offsetInCU: 0xA9, offset: 0x87D6D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC10texImage2Dyys5Int64V_s5Int32VA4HSpys5UInt8VGSuSo6CGSizeVSbtFZTo', symObjAddr: 0x30, symBinAddr: 0xFC00, symSize: 0x50 }
-  - { offsetInCU: 0x1A6, offset: 0x87E6A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC13texSubImage2Dyys5Int64V_s5Int32VA5HSpys5UInt8VGSuSo6CGSizeVSbtFZTo', symObjAddr: 0xC0, symBinAddr: 0xFC90, symSize: 0x50 }
-  - { offsetInCU: 0x289, offset: 0x87F4D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCACycfcTo', symObjAddr: 0x180, symBinAddr: 0xFD50, symSize: 0x30 }
-  - { offsetInCU: 0x2DD, offset: 0x87FA1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCMa', symObjAddr: 0x160, symBinAddr: 0xFD30, symSize: 0x20 }
-  - { offsetInCU: 0x487, offset: 0x8814B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC10texImage2Dyys5Int64V_s5Int32VA4HSpys5UInt8VGSuSo6CGSizeVSbtFZ', symObjAddr: 0x0, symBinAddr: 0xFBD0, symSize: 0x30 }
-  - { offsetInCU: 0x5DD, offset: 0x882A1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC13texSubImage2Dyys5Int64V_s5Int32VA5HSpys5UInt8VGSuSo6CGSizeVSbtFZ', symObjAddr: 0x80, symBinAddr: 0xFC50, symSize: 0x40 }
-  - { offsetInCU: 0x725, offset: 0x883E9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCACycfC', symObjAddr: 0x110, symBinAddr: 0xFCE0, symSize: 0x20 }
-  - { offsetInCU: 0x739, offset: 0x883FD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCACycfc', symObjAddr: 0x130, symBinAddr: 0xFD00, symSize: 0x30 }
-  - { offsetInCU: 0x76F, offset: 0x88433, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCfD', symObjAddr: 0x1B0, symBinAddr: 0xFD80, symSize: 0x2B }
-  - { offsetInCU: 0x61, offset: 0x884B7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7isDirtySbvgTo', symObjAddr: 0x10, symBinAddr: 0xFDC0, symSize: 0x20 }
-  - { offsetInCU: 0xB7, offset: 0x8850D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7isDirtySbvsTo', symObjAddr: 0x30, symBinAddr: 0xFDE0, symSize: 0x10 }
-  - { offsetInCU: 0x110, offset: 0x88566, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC6canvasAA9NSCCanvasCSgvgTo', symObjAddr: 0x40, symBinAddr: 0xFDF0, symSize: 0x40 }
-  - { offsetInCU: 0x168, offset: 0x885BE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC6canvasAA9NSCCanvasCSgvsTo', symObjAddr: 0xC0, symBinAddr: 0xFE70, symSize: 0x40 }
-  - { offsetInCU: 0x1C3, offset: 0x88619, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC3fbos6UInt32VvgTo', symObjAddr: 0x100, symBinAddr: 0xFEB0, symSize: 0x10 }
-  - { offsetInCU: 0x219, offset: 0x8866F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC3fbos6UInt32VvsTo', symObjAddr: 0x110, symBinAddr: 0xFEC0, symSize: 0x10 }
-  - { offsetInCU: 0x272, offset: 0x886C8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCACycfcTo', symObjAddr: 0x1C0, symBinAddr: 0xFF70, symSize: 0x80 }
-  - { offsetInCU: 0x2CA, offset: 0x88720, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frameACSo6CGRectV_tcfcTo', symObjAddr: 0x300, symBinAddr: 0x100B0, symSize: 0xA0 }
-  - { offsetInCU: 0x32C, offset: 0x88782, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5coderACSgSo7NSCoderC_tcfcTo', symObjAddr: 0x470, symBinAddr: 0x10220, symSize: 0x30 }
-  - { offsetInCU: 0x35E, offset: 0x887B4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC12bindDrawableyyFTo', symObjAddr: 0x520, symBinAddr: 0x10250, symSize: 0xA0 }
-  - { offsetInCU: 0x3DF, offset: 0x88835, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC14deleteDrawableyyFTo', symObjAddr: 0x600, symBinAddr: 0x102F0, symSize: 0x60 }
-  - { offsetInCU: 0x44F, offset: 0x888A5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7glkView_6drawInySo0C0C_So6CGRectVtFTo', symObjAddr: 0x670, symBinAddr: 0x10360, symSize: 0x50 }
-  - { offsetInCU: 0x4C1, offset: 0x88917, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frame7contextACSo6CGRectV_So11EAGLContextCtcfcTo', symObjAddr: 0x780, symBinAddr: 0x10470, symSize: 0x30 }
-  - { offsetInCU: 0x535, offset: 0x8898B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCMa', symObjAddr: 0x1A0, symBinAddr: 0xFF50, symSize: 0x20 }
-  - { offsetInCU: 0x55F, offset: 0x889B5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCfETo', symObjAddr: 0x7D0, symBinAddr: 0x104C0, symSize: 0x20 }
-  - { offsetInCU: 0x65D, offset: 0x88AB3, size: 0x8, addend: 0x0, symName: '_$sSo7GLKViewC12CanvasNativeE16snapshotWithDatayy10Foundation0F0VFTo', symObjAddr: 0xAF0, symBinAddr: 0x107E0, symSize: 0x80 }
-  - { offsetInCU: 0x69B, offset: 0x88AF1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC7isDirtySbvgTo', symObjAddr: 0xB70, symBinAddr: 0x10860, symSize: 0x20 }
-  - { offsetInCU: 0x6F1, offset: 0x88B47, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC7isDirtySbvsTo', symObjAddr: 0xB90, symBinAddr: 0x10880, symSize: 0x10 }
-  - { offsetInCU: 0x74A, offset: 0x88BA0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC8rendererAA9NSCCanvasCSgvgTo', symObjAddr: 0xBA0, symBinAddr: 0x10890, symSize: 0x20 }
-  - { offsetInCU: 0x7A2, offset: 0x88BF8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC8rendererAA9NSCCanvasCSgvsTo', symObjAddr: 0xBC0, symBinAddr: 0x108B0, symSize: 0x20 }
-  - { offsetInCU: 0x7FD, offset: 0x88C53, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvgTo', symObjAddr: 0xBE0, symBinAddr: 0x108D0, symSize: 0x40 }
-  - { offsetInCU: 0x853, offset: 0x88CA9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvsTo', symObjAddr: 0xC50, symBinAddr: 0x10940, symSize: 0x40 }
-  - { offsetInCU: 0x8E6, offset: 0x88D3C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCACycfcTo', symObjAddr: 0xDC0, symBinAddr: 0x10AB0, symSize: 0x80 }
-  - { offsetInCU: 0x93E, offset: 0x88D94, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5frameACSo6CGRectV_tcfcTo', symObjAddr: 0xF90, symBinAddr: 0x10C80, symSize: 0xA0 }
-  - { offsetInCU: 0x9A0, offset: 0x88DF6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5coderACSgSo7NSCoderC_tcfcTo', symObjAddr: 0x10E0, symBinAddr: 0x10DD0, symSize: 0x30 }
-  - { offsetInCU: 0x9D2, offset: 0x88E28, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC11deviceScaleSfyFTo', symObjAddr: 0x1110, symBinAddr: 0x10E00, symSize: 0xB0 }
-  - { offsetInCU: 0xA53, offset: 0x88EA9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC4drawyySo6CGRectVFTo', symObjAddr: 0x11D0, symBinAddr: 0x10EB0, symSize: 0x30 }
-  - { offsetInCU: 0xAB1, offset: 0x88F07, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCfETo', symObjAddr: 0x1250, symBinAddr: 0x10F30, symSize: 0x20 }
-  - { offsetInCU: 0xC63, offset: 0x890B9, size: 0x8, addend: 0x0, symName: '_$ss22_ContiguousArrayBufferV19_uninitializedCount15minimumCapacityAByxGSi_SitcfC12CanvasNative15NSCTouchHandlerC7PointerV_Tgm5', symObjAddr: 0x1470, symBinAddr: 0x110A0, symSize: 0x80 }
-  - { offsetInCU: 0xCE6, offset: 0x8913C, size: 0x8, addend: 0x0, symName: '_$ss22_ContiguousArrayBufferV19_uninitializedCount15minimumCapacityAByxGSi_SitcfCs5UInt8V_Tgm5', symObjAddr: 0x1570, symBinAddr: 0x11120, symSize: 0x70 }
-  - { offsetInCU: 0xD6A, offset: 0x891C0, size: 0x8, addend: 0x0, symName: '_$s10Foundation4DataV15_RepresentationOWOy', symObjAddr: 0x1750, symBinAddr: 0x11300, symSize: 0x40 }
-  - { offsetInCU: 0xD7E, offset: 0x891D4, size: 0x8, addend: 0x0, symName: '_$s10Foundation4DataV15_RepresentationOWOe', symObjAddr: 0x1790, symBinAddr: 0x11340, symSize: 0x40 }
-  - { offsetInCU: 0xD92, offset: 0x891E8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCMa', symObjAddr: 0x17D0, symBinAddr: 0x11380, symSize: 0x20 }
-  - { offsetInCU: 0xE6C, offset: 0x892C2, size: 0x8, addend: 0x0, symName: '_$sSaySayxGqd__c7ElementQyd__RszSTRd__lufCs5UInt8V_10Foundation4DataVTgm5Tf4g_n', symObjAddr: 0x1650, symBinAddr: 0x11200, symSize: 0x100 }
-  - { offsetInCU: 0x112B, offset: 0x89581, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC6canvasAA9NSCCanvasCSgvg', symObjAddr: 0x80, symBinAddr: 0xFE30, symSize: 0x40 }
-  - { offsetInCU: 0x11A8, offset: 0x895FE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCACycfc', symObjAddr: 0x120, symBinAddr: 0xFED0, symSize: 0x80 }
-  - { offsetInCU: 0x11EF, offset: 0x89645, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frameACSo6CGRectV_tcfc', symObjAddr: 0x240, symBinAddr: 0xFFF0, symSize: 0xC0 }
-  - { offsetInCU: 0x1251, offset: 0x896A7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5coderACSgSo7NSCoderC_tcfc', symObjAddr: 0x3A0, symBinAddr: 0x10150, symSize: 0xD0 }
-  - { offsetInCU: 0x12DA, offset: 0x89730, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7glkView_6drawInySo0C0C_So6CGRectVtF', symObjAddr: 0x660, symBinAddr: 0x10350, symSize: 0x10 }
-  - { offsetInCU: 0x12FB, offset: 0x89751, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frame7contextACSo6CGRectV_So11EAGLContextCtcfC', symObjAddr: 0x6C0, symBinAddr: 0x103B0, symSize: 0x90 }
-  - { offsetInCU: 0x130F, offset: 0x89765, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frame7contextACSo6CGRectV_So11EAGLContextCtcfc', symObjAddr: 0x750, symBinAddr: 0x10440, symSize: 0x30 }
-  - { offsetInCU: 0x1428, offset: 0x8987E, size: 0x8, addend: 0x0, symName: '_$sSo7GLKViewC12CanvasNativeE16snapshotWithDatayy10Foundation0F0VF', symObjAddr: 0x7F0, symBinAddr: 0x104E0, symSize: 0x300 }
-  - { offsetInCU: 0x17D2, offset: 0x89C28, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvg', symObjAddr: 0xC20, symBinAddr: 0x10910, symSize: 0x30 }
-  - { offsetInCU: 0x180F, offset: 0x89C65, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvs', symObjAddr: 0xC90, symBinAddr: 0x10980, symSize: 0x40 }
-  - { offsetInCU: 0x1836, offset: 0x89C8C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvM', symObjAddr: 0xCD0, symBinAddr: 0x109C0, symSize: 0x40 }
-  - { offsetInCU: 0x185B, offset: 0x89CB1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvM.resume.0', symObjAddr: 0xD10, symBinAddr: 0x10A00, symSize: 0x10 }
-  - { offsetInCU: 0x1882, offset: 0x89CD8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCACycfC', symObjAddr: 0xD20, symBinAddr: 0x10A10, symSize: 0x20 }
-  - { offsetInCU: 0x1896, offset: 0x89CEC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCACycfc', symObjAddr: 0xD40, symBinAddr: 0x10A30, symSize: 0x80 }
-  - { offsetInCU: 0x18DD, offset: 0x89D33, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5frameACSo6CGRectV_tcfc', symObjAddr: 0xED0, symBinAddr: 0x10BC0, symSize: 0xC0 }
-  - { offsetInCU: 0x193A, offset: 0x89D90, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5coderACSgSo7NSCoderC_tcfc', symObjAddr: 0x1030, symBinAddr: 0x10D20, symSize: 0xB0 }
-  - { offsetInCU: 0x19D6, offset: 0x89E2C, size: 0x8, addend: 0x0, symName: '_$ss12_ArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtF12CanvasNative15NSCTouchHandlerC7PointerV_Tg5', symObjAddr: 0x1270, symBinAddr: 0x10F50, symSize: 0xB0 }
-  - { offsetInCU: 0x1AB8, offset: 0x89F0E, size: 0x8, addend: 0x0, symName: '_$ss12_ArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtFs5UInt8V_Tg5', symObjAddr: 0x13D0, symBinAddr: 0x11000, symSize: 0xA0 }
-  - { offsetInCU: 0x1BC4, offset: 0x8A01A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7glkView_6drawInySo0C0C_So6CGRectVtFTf4ddn_n', symObjAddr: 0x15E0, symBinAddr: 0x11190, symSize: 0x70 }
-  - { offsetInCU: 0x1CBF, offset: 0x8A115, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC4drawyySo6CGRectVFTf4dn_n', symObjAddr: 0x17F0, symBinAddr: 0x113A0, symSize: 0x410 }
-  - { offsetInCU: 0x4F, offset: 0x8A52D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC5queue33_7ED578B0ED4B2B6F6887A622A7B49AA3LLSo012OS_dispatch_E0CvpZ', symObjAddr: 0x980, symBinAddr: 0x12D3310, symSize: 0x0 }
-  - { offsetInCU: 0x5D, offset: 0x8A53B, size: 0x8, addend: 0x0, symName: '_$sIegh_IeyBh_TR', symObjAddr: 0x0, symBinAddr: 0x119A0, symSize: 0x30 }
-  - { offsetInCU: 0x75, offset: 0x8A553, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC5queue33_7ED578B0ED4B2B6F6887A622A7B49AA3LL_WZ', symObjAddr: 0x30, symBinAddr: 0x119D0, symSize: 0xF0 }
-  - { offsetInCU: 0xBC, offset: 0x8A59A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF4SyncySbs5Int64V_So7UIImageCtFZTo', symObjAddr: 0x130, symBinAddr: 0x11AD0, symSize: 0x40 }
-  - { offsetInCU: 0x130, offset: 0x8A60E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZTo', symObjAddr: 0x3C0, symBinAddr: 0x11D60, symSize: 0x80 }
-  - { offsetInCU: 0x18F, offset: 0x8A66D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCACycfcTo', symObjAddr: 0x490, symBinAddr: 0x11E30, symSize: 0x30 }
-  - { offsetInCU: 0x1E2, offset: 0x8A6C0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZTf4nnnd_n', symObjAddr: 0x500, symBinAddr: 0x11EA0, symSize: 0x200 }
-  - { offsetInCU: 0x261, offset: 0x8A73F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCfETo', symObjAddr: 0x4F0, symBinAddr: 0x11E90, symSize: 0x10 }
-  - { offsetInCU: 0x29D, offset: 0x8A77B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCMa', symObjAddr: 0x700, symBinAddr: 0x120A0, symSize: 0x20 }
-  - { offsetInCU: 0x2BC, offset: 0x8A79A, size: 0x8, addend: 0x0, symName: '_$s10ObjectiveC8ObjCBoolVIeyBy_SbIegy_TRTA', symObjAddr: 0x740, symBinAddr: 0x120E0, symSize: 0x20 }
-  - { offsetInCU: 0x2E5, offset: 0x8A7C3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_TA', symObjAddr: 0x790, symBinAddr: 0x12130, symSize: 0x20 }
-  - { offsetInCU: 0x2F9, offset: 0x8A7D7, size: 0x8, addend: 0x0, symName: _block_copy_helper, symObjAddr: 0x7B0, symBinAddr: 0x12150, symSize: 0x20 }
-  - { offsetInCU: 0x30D, offset: 0x8A7EB, size: 0x8, addend: 0x0, symName: _block_destroy_helper, symObjAddr: 0x7D0, symBinAddr: 0x12170, symSize: 0x10 }
-  - { offsetInCU: 0x321, offset: 0x8A7FF, size: 0x8, addend: 0x0, symName: '_$sSay8Dispatch0A13WorkItemFlagsVGMa', symObjAddr: 0x850, symBinAddr: 0x121B0, symSize: 0x50 }
-  - { offsetInCU: 0x335, offset: 0x8A813, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_yyScMYccfU0_TA', symObjAddr: 0x8D0, symBinAddr: 0x12200, symSize: 0x20 }
-  - { offsetInCU: 0x369, offset: 0x8A847, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_yyScMYccfU_TA', symObjAddr: 0x910, symBinAddr: 0x12240, symSize: 0x20 }
-  - { offsetInCU: 0x4FE, offset: 0x8A9DC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF4SyncySbs5Int64V_So7UIImageCtFZ', symObjAddr: 0x120, symBinAddr: 0x11AC0, symSize: 0x10 }
-  - { offsetInCU: 0x58B, offset: 0x8AA69, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZ', symObjAddr: 0x170, symBinAddr: 0x11B10, symSize: 0x10 }
-  - { offsetInCU: 0x59F, offset: 0x8AA7D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_', symObjAddr: 0x180, symBinAddr: 0x11B20, symSize: 0x240 }
-  - { offsetInCU: 0x678, offset: 0x8AB56, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCACycfC', symObjAddr: 0x440, symBinAddr: 0x11DE0, symSize: 0x20 }
-  - { offsetInCU: 0x68C, offset: 0x8AB6A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCACycfc', symObjAddr: 0x460, symBinAddr: 0x11E00, symSize: 0x30 }
-  - { offsetInCU: 0x6C2, offset: 0x8ABA0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCfD', symObjAddr: 0x4C0, symBinAddr: 0x11E60, symSize: 0x30 }
-  - { offsetInCU: 0x27, offset: 0x8AC46, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfC', symObjAddr: 0x0, symBinAddr: 0x122B0, symSize: 0x20 }
-  - { offsetInCU: 0x77, offset: 0x8AC96, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfcTo', symObjAddr: 0x70, symBinAddr: 0x12320, symSize: 0x30 }
-  - { offsetInCU: 0xCB, offset: 0x8ACEA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCMa', symObjAddr: 0x50, symBinAddr: 0x12300, symSize: 0x20 }
-  - { offsetInCU: 0x216, offset: 0x8AE35, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfC', symObjAddr: 0x0, symBinAddr: 0x122B0, symSize: 0x20 }
-  - { offsetInCU: 0x22A, offset: 0x8AE49, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfc', symObjAddr: 0x20, symBinAddr: 0x122D0, symSize: 0x30 }
-  - { offsetInCU: 0x266, offset: 0x8AE85, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCfD', symObjAddr: 0xA0, symBinAddr: 0x12350, symSize: 0x2B }
-  - { offsetInCU: 0x26, offset: 0x8AECE, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_frombytes_vartime, symObjAddr: 0x0, symBinAddr: 0x348B60, symSize: 0x3990 }
-  - { offsetInCU: 0x40, offset: 0x8AEE8, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_k25519Precomp, symObjAddr: 0xEEC0, symBinAddr: 0xAD3690, symSize: 0x0 }
-  - { offsetInCU: 0x92, offset: 0x8AF3A, size: 0x8, addend: 0x0, symName: _d, symObjAddr: 0x14EC0, symBinAddr: 0xAD9690, symSize: 0x0 }
-  - { offsetInCU: 0xF6, offset: 0x8AF9E, size: 0x8, addend: 0x0, symName: _sqrtm1, symObjAddr: 0x14EE8, symBinAddr: 0xAD96B8, symSize: 0x0 }
-  - { offsetInCU: 0x10C, offset: 0x8AFB4, size: 0x8, addend: 0x0, symName: _d2, symObjAddr: 0x152F0, symBinAddr: 0xAD9AC0, symSize: 0x0 }
-  - { offsetInCU: 0x123, offset: 0x8AFCB, size: 0x8, addend: 0x0, symName: _Bi, symObjAddr: 0x14F30, symBinAddr: 0xAD9700, symSize: 0x0 }
-  - { offsetInCU: 0xE22, offset: 0x8BCCA, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_frombytes_vartime, symObjAddr: 0x0, symBinAddr: 0x348B60, symSize: 0x3990 }
-  - { offsetInCU: 0x4DAE, offset: 0x8FC56, size: 0x8, addend: 0x0, symName: _fe_mul_impl, symObjAddr: 0xE6E0, symBinAddr: 0x357240, symSize: 0x3E0 }
-  - { offsetInCU: 0x4FF1, offset: 0x8FE99, size: 0x8, addend: 0x0, symName: _fe_tobytes, symObjAddr: 0x7C20, symBinAddr: 0x350780, symSize: 0x270 }
-  - { offsetInCU: 0x582C, offset: 0x906D4, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_scalarmult_base, symObjAddr: 0x3990, symBinAddr: 0x34C4F0, symSize: 0xA10 }
-  - { offsetInCU: 0x684B, offset: 0x916F3, size: 0x8, addend: 0x0, symName: _table_select, symObjAddr: 0x43A0, symBinAddr: 0x34CF00, symSize: 0xA10 }
-  - { offsetInCU: 0x6EE9, offset: 0x91D91, size: 0x8, addend: 0x0, symName: _ge_madd, symObjAddr: 0x4DB0, symBinAddr: 0x34D910, symSize: 0x2B0 }
-  - { offsetInCU: 0x74BC, offset: 0x92364, size: 0x8, addend: 0x0, symName: _ge_p2_dbl, symObjAddr: 0x5060, symBinAddr: 0x34DBC0, symSize: 0xCD0 }
-  - { offsetInCU: 0x83FE, offset: 0x932A6, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_sc_reduce, symObjAddr: 0x5D30, symBinAddr: 0x34E890, symSize: 0xB40 }
-  - { offsetInCU: 0x8F67, offset: 0x93E0F, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_scalar_mult_generic_masked, symObjAddr: 0x6870, symBinAddr: 0x34F3D0, symSize: 0x13B0 }
-  - { offsetInCU: 0xA567, offset: 0x9540F, size: 0x8, addend: 0x0, symName: _fe_loose_invert, symObjAddr: 0x7FF0, symBinAddr: 0x350B50, symSize: 0x2A30 }
-  - { offsetInCU: 0xDC6D, offset: 0x98B15, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_public_from_private_generic_masked, symObjAddr: 0x7E90, symBinAddr: 0x3509F0, symSize: 0x160 }
-  - { offsetInCU: 0xDEE7, offset: 0x98D8F, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_invert, symObjAddr: 0xAA20, symBinAddr: 0x353580, symSize: 0x30 }
-  - { offsetInCU: 0xDFDC, offset: 0x98E84, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_isnegative, symObjAddr: 0xAA50, symBinAddr: 0x3535B0, symSize: 0x50 }
-  - { offsetInCU: 0xE051, offset: 0x98EF9, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_mul_ttt, symObjAddr: 0xAAA0, symBinAddr: 0x353600, symSize: 0x10 }
-  - { offsetInCU: 0xE0EC, offset: 0x98F94, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_neg, symObjAddr: 0xAAB0, symBinAddr: 0x353610, symSize: 0xB0 }
-  - { offsetInCU: 0xE217, offset: 0x990BF, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_tobytes, symObjAddr: 0xAB60, symBinAddr: 0x3536C0, symSize: 0x10 }
-  - { offsetInCU: 0xE4E9, offset: 0x99391, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_double_scalarmult_vartime, symObjAddr: 0xAB70, symBinAddr: 0x3536D0, symSize: 0x21A0 }
-  - { offsetInCU: 0x1118F, offset: 0x9C037, size: 0x8, addend: 0x0, symName: _x25519_ge_add, symObjAddr: 0xEAC0, symBinAddr: 0x357620, symSize: 0x2D1 }
-  - { offsetInCU: 0x117CF, offset: 0x9C677, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_sc_mask, symObjAddr: 0xCD10, symBinAddr: 0x355870, symSize: 0x20 }
-  - { offsetInCU: 0x11C6C, offset: 0x9CB14, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_sc_muladd, symObjAddr: 0xCD30, symBinAddr: 0x355890, symSize: 0x19B0 }
-  - { offsetInCU: 0x26, offset: 0x9DBC4, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_nohw_set_encrypt_key, symObjAddr: 0x0, symBinAddr: 0x357900, symSize: 0x800 }
-  - { offsetInCU: 0x41, offset: 0x9DBDF, size: 0x8, addend: 0x0, symName: _aes_nohw_rcon, symObjAddr: 0x1B10, symBinAddr: 0xAD9BA0, symSize: 0x0 }
-  - { offsetInCU: 0x484, offset: 0x9E022, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_nohw_set_encrypt_key, symObjAddr: 0x0, symBinAddr: 0x357900, symSize: 0x800 }
-  - { offsetInCU: 0x1B2B, offset: 0x9F6C9, size: 0x8, addend: 0x0, symName: _aes_nohw_sub_bytes, symObjAddr: 0x15F0, symBinAddr: 0x358EF0, symSize: 0x300 }
-  - { offsetInCU: 0x32EE, offset: 0xA0E8C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_nohw_encrypt, symObjAddr: 0x800, symBinAddr: 0x358100, symSize: 0x80 }
-  - { offsetInCU: 0x33DC, offset: 0xA0F7A, size: 0x8, addend: 0x0, symName: _aes_nohw_expand_round_keys, symObjAddr: 0x880, symBinAddr: 0x358180, symSize: 0x1A0 }
-  - { offsetInCU: 0x386D, offset: 0xA140B, size: 0x8, addend: 0x0, symName: _aes_nohw_to_batch, symObjAddr: 0xA20, symBinAddr: 0x358320, symSize: 0x420 }
-  - { offsetInCU: 0x3D7D, offset: 0xA191B, size: 0x8, addend: 0x0, symName: _aes_nohw_encrypt_batch, symObjAddr: 0xE40, symBinAddr: 0x358740, symSize: 0x380 }
-  - { offsetInCU: 0x424C, offset: 0xA1DEA, size: 0x8, addend: 0x0, symName: _aes_nohw_from_batch, symObjAddr: 0x11C0, symBinAddr: 0x358AC0, symSize: 0x250 }
-  - { offsetInCU: 0x498D, offset: 0xA252B, size: 0x8, addend: 0x0, symName: _aes_nohw_shift_rows, symObjAddr: 0x18F0, symBinAddr: 0x3591F0, symSize: 0x149 }
-  - { offsetInCU: 0x4BF9, offset: 0xA2797, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_nohw_ctr32_encrypt_blocks, symObjAddr: 0x1410, symBinAddr: 0x358D10, symSize: 0x1E0 }
-  - { offsetInCU: 0x26, offset: 0xA2BB8, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_from_montgomery_in_place, symObjAddr: 0x0, symBinAddr: 0x359340, symSize: 0x2DC }
-  - { offsetInCU: 0x1D2, offset: 0xA2D64, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_from_montgomery_in_place, symObjAddr: 0x0, symBinAddr: 0x359340, symSize: 0x2DC }
-  - { offsetInCU: 0x26, offset: 0xA2FBD, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_neg_inv_mod_r_u64, symObjAddr: 0x0, symBinAddr: 0x359620, symSize: 0x87 }
-  - { offsetInCU: 0x34, offset: 0xA2FCB, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_neg_inv_mod_r_u64, symObjAddr: 0x0, symBinAddr: 0x359620, symSize: 0x87 }
-  - { offsetInCU: 0x26, offset: 0xA30DB, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_little_endian_bytes_from_scalar, symObjAddr: 0x0, symBinAddr: 0x3596B0, symSize: 0x46 }
-  - { offsetInCU: 0x34, offset: 0xA30E9, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_little_endian_bytes_from_scalar, symObjAddr: 0x0, symBinAddr: 0x3596B0, symSize: 0x46 }
-  - { offsetInCU: 0x86, offset: 0xA324C, size: 0x8, addend: 0x0, symName: _Q_N0, symObjAddr: 0x15F0, symBinAddr: 0xAD9C20, symSize: 0x0 }
-  - { offsetInCU: 0xB8, offset: 0xA327E, size: 0x8, addend: 0x0, symName: _Q, symObjAddr: 0x1580, symBinAddr: 0xAD9BB0, symSize: 0x0 }
-  - { offsetInCU: 0xDA, offset: 0xA32A0, size: 0x8, addend: 0x0, symName: _N, symObjAddr: 0x15B0, symBinAddr: 0xAD9BE0, symSize: 0x0 }
-  - { offsetInCU: 0xF0, offset: 0xA32B6, size: 0x8, addend: 0x0, symName: _N_N0, symObjAddr: 0x15E0, symBinAddr: 0xAD9C10, symSize: 0x0 }
-  - { offsetInCU: 0x3B7, offset: 0xA357D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_elem_mul_mont, symObjAddr: 0x150, symBinAddr: 0x359700, symSize: 0x20 }
-  - { offsetInCU: 0x594, offset: 0xA375A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_scalar_mul_mont, symObjAddr: 0x250, symBinAddr: 0x359720, symSize: 0x20 }
-  - { offsetInCU: 0x63F, offset: 0xA3805, size: 0x8, addend: 0x0, symName: _nistz384_point_double, symObjAddr: 0x340, symBinAddr: 0x359740, symSize: 0x3A0 }
-  - { offsetInCU: 0x11A7, offset: 0xA436D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_point_add, symObjAddr: 0x6E0, symBinAddr: 0x359AE0, symSize: 0x140 }
-  - { offsetInCU: 0x14A2, offset: 0xA4668, size: 0x8, addend: 0x0, symName: _nistz384_point_add, symObjAddr: 0x820, symBinAddr: 0x359C20, symSize: 0x6B0 }
-  - { offsetInCU: 0x26DA, offset: 0xA58A0, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_point_mul, symObjAddr: 0xED0, symBinAddr: 0x35A2D0, symSize: 0x380 }
-  - { offsetInCU: 0x2D37, offset: 0xA5EFD, size: 0x8, addend: 0x0, symName: _p384_point_select_w5, symObjAddr: 0x1250, symBinAddr: 0x35A650, symSize: 0x170 }
-  - { offsetInCU: 0x2F2F, offset: 0xA60F5, size: 0x8, addend: 0x0, symName: _add_precomputed_w5, symObjAddr: 0x13C0, symBinAddr: 0x35A7C0, symSize: 0x1BF }
-  - { offsetInCU: 0x26, offset: 0xA6440, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_zero, symObjAddr: 0x0, symBinAddr: 0x35A980, symSize: 0x50 }
-  - { offsetInCU: 0xFA, offset: 0xA6514, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_zero, symObjAddr: 0x0, symBinAddr: 0x35A980, symSize: 0x50 }
-  - { offsetInCU: 0x18D, offset: 0xA65A7, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_equal, symObjAddr: 0x50, symBinAddr: 0x35A9D0, symSize: 0x60 }
-  - { offsetInCU: 0x2F1, offset: 0xA670B, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_equal_limb, symObjAddr: 0xB0, symBinAddr: 0x35AA30, symSize: 0x90 }
-  - { offsetInCU: 0x4C6, offset: 0xA68E0, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_even, symObjAddr: 0x140, symBinAddr: 0x35AAC0, symSize: 0x20 }
-  - { offsetInCU: 0x5E3, offset: 0xA69FD, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_less_than, symObjAddr: 0x160, symBinAddr: 0x35AAE0, symSize: 0xB0 }
-  - { offsetInCU: 0x696, offset: 0xA6AB0, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_less_than_limb, symObjAddr: 0x210, symBinAddr: 0x35AB90, symSize: 0x70 }
-  - { offsetInCU: 0x861, offset: 0xA6C7B, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_reduce_once, symObjAddr: 0x280, symBinAddr: 0x35AC00, symSize: 0x170 }
-  - { offsetInCU: 0xB67, offset: 0xA6F81, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_add_mod, symObjAddr: 0x3F0, symBinAddr: 0x35AD70, symSize: 0x270 }
-  - { offsetInCU: 0xE6A, offset: 0xA7284, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_sub_mod, symObjAddr: 0x660, symBinAddr: 0x35AFE0, symSize: 0x1A0 }
-  - { offsetInCU: 0x105D, offset: 0xA7477, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_shl_mod, symObjAddr: 0x800, symBinAddr: 0x35B180, symSize: 0x280 }
-  - { offsetInCU: 0x128C, offset: 0xA76A6, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_window5_split_window, symObjAddr: 0xC20, symBinAddr: 0x35B400, symSize: 0x20 }
-  - { offsetInCU: 0x12F3, offset: 0xA770D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_window5_unsplit_window, symObjAddr: 0xC40, symBinAddr: 0x35B420, symSize: 0x20 }
-  - { offsetInCU: 0x132A, offset: 0xA7744, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMB_shr, symObjAddr: 0xC60, symBinAddr: 0x35B440, symSize: 0x10 }
-  - { offsetInCU: 0x13AC, offset: 0xA77C6, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_limbs_mul_add_limb, symObjAddr: 0xC70, symBinAddr: 0x35B450, symSize: 0x4A }
-  - { offsetInCU: 0x26, offset: 0xA7952, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_CRYPTO_memcmp, symObjAddr: 0x0, symBinAddr: 0x35B4A0, symSize: 0x129 }
-  - { offsetInCU: 0x34, offset: 0xA7960, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_CRYPTO_memcmp, symObjAddr: 0x0, symBinAddr: 0x35B4A0, symSize: 0x129 }
-  - { offsetInCU: 0x34, offset: 0xA7A62, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_OPENSSL_ia32cap_P, symObjAddr: 0x3F0, symBinAddr: 0x12DA4F0, symSize: 0x0 }
-  - { offsetInCU: 0x26, offset: 0xA7AB7, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_OPENSSL_cpuid_setup, symObjAddr: 0x0, symBinAddr: 0x35B5D0, symSize: 0xF8 }
-  - { offsetInCU: 0xD5, offset: 0xA7B66, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_OPENSSL_cpuid_setup, symObjAddr: 0x0, symBinAddr: 0x35B5D0, symSize: 0xF8 }
-  - { offsetInCU: 0x26, offset: 0xA7CBB, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_scalar_mult_adx, symObjAddr: 0x0, symBinAddr: 0x35B6D0, symSize: 0x1210 }
-  - { offsetInCU: 0x92E, offset: 0xA85C3, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_scalar_mult_adx, symObjAddr: 0x0, symBinAddr: 0x35B6D0, symSize: 0x1210 }
-  - { offsetInCU: 0x5347, offset: 0xACFDC, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_scalarmult_base_adx, symObjAddr: 0x1210, symBinAddr: 0x35C8E0, symSize: 0x1E50 }
-  - { offsetInCU: 0x9B2F, offset: 0xB17C4, size: 0x8, addend: 0x0, symName: _inline_x25519_ge_dbl_4, symObjAddr: 0x3060, symBinAddr: 0x35E730, symSize: 0x361 }
-  - { offsetInCU: 0x26, offset: 0xB2BB1, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_CRYPTO_poly1305_init, symObjAddr: 0x0, symBinAddr: 0x35EAA0, symSize: 0xD0 }
-  - { offsetInCU: 0x303, offset: 0xB2E8E, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_CRYPTO_poly1305_init, symObjAddr: 0x0, symBinAddr: 0x35EAA0, symSize: 0xD0 }
-  - { offsetInCU: 0x5A4, offset: 0xB312F, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_CRYPTO_poly1305_update, symObjAddr: 0xD0, symBinAddr: 0x35EB70, symSize: 0x1C0 }
-  - { offsetInCU: 0x764, offset: 0xB32EF, size: 0x8, addend: 0x0, symName: _poly1305_blocks, symObjAddr: 0x5F0, symBinAddr: 0x35F090, symSize: 0x780 }
-  - { offsetInCU: 0x903, offset: 0xB348E, size: 0x8, addend: 0x0, symName: _poly1305_first_block, symObjAddr: 0x290, symBinAddr: 0x35ED30, symSize: 0x360 }
-  - { offsetInCU: 0xEFC, offset: 0xB3A87, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_CRYPTO_poly1305_finish, symObjAddr: 0xD70, symBinAddr: 0x35F810, symSize: 0xAA2 }
-  - { offsetInCU: 0x10, offset: 0xB4210, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_fiat_curve25519_adx_mul, symObjAddr: 0x0, symBinAddr: 0x3602B2, symSize: 0x2AF }
-  - { offsetInCU: 0x51, offset: 0xB4251, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_fiat_curve25519_adx_mul, symObjAddr: 0x0, symBinAddr: 0x3602B2, symSize: 0x2AF }
-  - { offsetInCU: 0x10, offset: 0xB4246, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_fiat_curve25519_adx_square, symObjAddr: 0x0, symBinAddr: 0x360561, symSize: 0x1F4 }
-  - { offsetInCU: 0x54, offset: 0xB428A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_fiat_curve25519_adx_square, symObjAddr: 0x0, symBinAddr: 0x360561, symSize: 0x1F4 }
-  - { offsetInCU: 0x26, offset: 0xB4292, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul, symObjAddr: 0x0, symBinAddr: 0x360760, symSize: 0x490 }
-  - { offsetInCU: 0x76, offset: 0xB42E2, size: 0x8, addend: 0x0, symName: _ecp_nistz256_precomputed, symObjAddr: 0x1000, symBinAddr: 0xADA000, symSize: 0x0 }
-  - { offsetInCU: 0xFA, offset: 0xB4366, size: 0x8, addend: 0x0, symName: _ONE, symObjAddr: 0x26000, symBinAddr: 0xAFF000, symSize: 0x0 }
-  - { offsetInCU: 0x35B, offset: 0xB45C7, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul, symObjAddr: 0x0, symBinAddr: 0x360760, symSize: 0x490 }
-  - { offsetInCU: 0xC5A, offset: 0xB4EC6, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul_base, symObjAddr: 0x490, symBinAddr: 0x360BF0, symSize: 0x300 }
-  - { offsetInCU: 0x1135, offset: 0xB53A1, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul_base_vartime, symObjAddr: 0x790, symBinAddr: 0x360EF0, symSize: 0x25D }
-  - { offsetInCU: 0x10, offset: 0xB5766, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ChaCha20_ctr32, symObjAddr: 0x0, symBinAddr: 0x361180, symSize: 0x3A0 }
-  - { offsetInCU: 0x48, offset: 0xB579E, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ChaCha20_ctr32, symObjAddr: 0x0, symBinAddr: 0x361180, symSize: 0x3A0 }
-  - { offsetInCU: 0x4D, offset: 0xB57A3, size: 0x8, addend: 0x0, symName: ChaCha20_ssse3, symObjAddr: 0x3A0, symBinAddr: 0x361520, symSize: 0x220 }
-  - { offsetInCU: 0x60, offset: 0xB57B6, size: 0x8, addend: 0x0, symName: ChaCha20_4x, symObjAddr: 0x5C0, symBinAddr: 0x361740, symSize: 0xA20 }
-  - { offsetInCU: 0x76, offset: 0xB57CC, size: 0x8, addend: 0x0, symName: ChaCha20_8x, symObjAddr: 0xFE0, symBinAddr: 0x362160, symSize: 0xB4C }
-  - { offsetInCU: 0x10, offset: 0xB57DE, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_encrypt, symObjAddr: 0x0, symBinAddr: 0x362CC0, symSize: 0x40 }
-  - { offsetInCU: 0x48, offset: 0xB5816, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_encrypt, symObjAddr: 0x0, symBinAddr: 0x362CC0, symSize: 0x40 }
-  - { offsetInCU: 0x4D, offset: 0xB581B, size: 0x8, addend: 0x0, symName: _aesni_encrypt2, symObjAddr: 0x40, symBinAddr: 0x362D00, symSize: 0x60 }
-  - { offsetInCU: 0x63, offset: 0xB5831, size: 0x8, addend: 0x0, symName: _aesni_encrypt3, symObjAddr: 0xA0, symBinAddr: 0x362D60, symSize: 0x70 }
-  - { offsetInCU: 0x79, offset: 0xB5847, size: 0x8, addend: 0x0, symName: _aesni_encrypt4, symObjAddr: 0x110, symBinAddr: 0x362DD0, symSize: 0x90 }
-  - { offsetInCU: 0x8F, offset: 0xB585D, size: 0x8, addend: 0x0, symName: _aesni_encrypt6, symObjAddr: 0x1A0, symBinAddr: 0x362E60, symSize: 0xE0 }
-  - { offsetInCU: 0xA5, offset: 0xB5873, size: 0x8, addend: 0x0, symName: _aesni_encrypt8, symObjAddr: 0x280, symBinAddr: 0x362F40, symSize: 0x110 }
-  - { offsetInCU: 0xD9, offset: 0xB58A7, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_ctr32_encrypt_blocks, symObjAddr: 0x390, symBinAddr: 0x363050, symSize: 0x940 }
-  - { offsetInCU: 0xEA, offset: 0xB58B8, size: 0x8, addend: 0x0, symName: __aesni_set_encrypt_key, symObjAddr: 0xCD0, symBinAddr: 0x363990, symSize: 0x44D }
-  - { offsetInCU: 0x10, offset: 0xB58AE, size: 0x8, addend: 0x0, symName: _vpaes_encrypt_core, symObjAddr: 0x0, symBinAddr: 0x363DE0, symSize: 0x160 }
-  - { offsetInCU: 0x3B, offset: 0xB58D9, size: 0x8, addend: 0x0, symName: _vpaes_encrypt_core, symObjAddr: 0x0, symBinAddr: 0x363DE0, symSize: 0x160 }
-  - { offsetInCU: 0x54, offset: 0xB58F2, size: 0x8, addend: 0x0, symName: _vpaes_encrypt_core_2x, symObjAddr: 0x160, symBinAddr: 0x363F40, symSize: 0x290 }
-  - { offsetInCU: 0x68, offset: 0xB5906, size: 0x8, addend: 0x0, symName: _vpaes_schedule_core, symObjAddr: 0x3F0, symBinAddr: 0x3641D0, symSize: 0xF0 }
-  - { offsetInCU: 0x7F, offset: 0xB591D, size: 0x8, addend: 0x0, symName: _vpaes_schedule_round, symObjAddr: 0x4E0, symBinAddr: 0x3642C0, symSize: 0x21 }
-  - { offsetInCU: 0x99, offset: 0xB5937, size: 0x8, addend: 0x0, symName: _vpaes_schedule_low_round, symObjAddr: 0x501, symBinAddr: 0x3642E1, symSize: 0x9F }
-  - { offsetInCU: 0xAF, offset: 0xB594D, size: 0x8, addend: 0x0, symName: _vpaes_schedule_transform, symObjAddr: 0x5A0, symBinAddr: 0x364380, symSize: 0x30 }
-  - { offsetInCU: 0xC2, offset: 0xB5960, size: 0x8, addend: 0x0, symName: _vpaes_schedule_mangle, symObjAddr: 0x5D0, symBinAddr: 0x3643B0, symSize: 0x50 }
-  - { offsetInCU: 0xE9, offset: 0xB5987, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_vpaes_set_encrypt_key, symObjAddr: 0x620, symBinAddr: 0x364400, symSize: 0x30 }
-  - { offsetInCU: 0xF7, offset: 0xB5995, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_vpaes_encrypt, symObjAddr: 0x650, symBinAddr: 0x364430, symSize: 0x20 }
-  - { offsetInCU: 0x11A, offset: 0xB59B8, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_vpaes_ctr32_encrypt_blocks, symObjAddr: 0x670, symBinAddr: 0x364450, symSize: 0xD0 }
-  - { offsetInCU: 0x112, offset: 0xB59B0, size: 0x8, addend: 0x0, symName: _vpaes_preheat, symObjAddr: 0x740, symBinAddr: 0x364520, symSize: 0x31 }
-  - { offsetInCU: 0x10, offset: 0xB59C0, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_mul_mont, symObjAddr: 0x0, symBinAddr: 0x364560, symSize: 0x2A0 }
-  - { offsetInCU: 0x45, offset: 0xB59F5, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_mul_mont, symObjAddr: 0x0, symBinAddr: 0x364560, symSize: 0x2A0 }
-  - { offsetInCU: 0x4C, offset: 0xB59FC, size: 0x8, addend: 0x0, symName: bn_mul4x_mont, symObjAddr: 0x2A0, symBinAddr: 0x364800, symSize: 0x560 }
-  - { offsetInCU: 0x62, offset: 0xB5A12, size: 0x8, addend: 0x0, symName: bn_sqr8x_mont, symObjAddr: 0x800, symBinAddr: 0x364D60, symSize: 0x220 }
-  - { offsetInCU: 0x79, offset: 0xB5A29, size: 0x8, addend: 0x0, symName: bn_mulx4x_mont, symObjAddr: 0xA20, symBinAddr: 0x364F80, symSize: 0x570 }
-  - { offsetInCU: 0x10, offset: 0xB5A38, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_mul_mont_gather5, symObjAddr: 0x0, symBinAddr: 0x365500, symSize: 0x660 }
-  - { offsetInCU: 0x4D, offset: 0xB5A75, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_mul_mont_gather5, symObjAddr: 0x0, symBinAddr: 0x365500, symSize: 0x660 }
-  - { offsetInCU: 0x54, offset: 0xB5A7C, size: 0x8, addend: 0x0, symName: bn_mul4x_mont_gather5, symObjAddr: 0x660, symBinAddr: 0x365B60, symSize: 0x100 }
-  - { offsetInCU: 0x63, offset: 0xB5A8B, size: 0x8, addend: 0x0, symName: mul4x_internal, symObjAddr: 0x760, symBinAddr: 0x365C60, symSize: 0x7E0 }
-  - { offsetInCU: 0x85, offset: 0xB5AAD, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_power5, symObjAddr: 0xF40, symBinAddr: 0x366440, symSize: 0x180 }
-  - { offsetInCU: 0xA3, offset: 0xB5ACB, size: 0x8, addend: 0x0, symName: __bn_sqr8x_internal, symObjAddr: 0x10C0, symBinAddr: 0x3665C0, symSize: 0x579 }
-  - { offsetInCU: 0xAA, offset: 0xB5AD2, size: 0x8, addend: 0x0, symName: __bn_sqr8x_reduction, symObjAddr: 0x1639, symBinAddr: 0x366B39, symSize: 0x347 }
-  - { offsetInCU: 0xC0, offset: 0xB5AE8, size: 0x8, addend: 0x0, symName: __bn_post4x_internal, symObjAddr: 0x1980, symBinAddr: 0x366E80, symSize: 0xA0 }
-  - { offsetInCU: 0xD9, offset: 0xB5B01, size: 0x8, addend: 0x0, symName: bn_mulx4x_mont_gather5, symObjAddr: 0x1A20, symBinAddr: 0x366F20, symSize: 0xE0 }
-  - { offsetInCU: 0xE8, offset: 0xB5B10, size: 0x8, addend: 0x0, symName: mulx4x_internal, symObjAddr: 0x1B00, symBinAddr: 0x367000, symSize: 0x7E0 }
-  - { offsetInCU: 0xF9, offset: 0xB5B21, size: 0x8, addend: 0x0, symName: bn_powerx5, symObjAddr: 0x22E0, symBinAddr: 0x3677E0, symSize: 0x160 }
-  - { offsetInCU: 0x128, offset: 0xB5B50, size: 0x8, addend: 0x0, symName: __bn_sqrx8x_internal, symObjAddr: 0x2440, symBinAddr: 0x367940, symSize: 0x637 }
-  - { offsetInCU: 0x12F, offset: 0xB5B57, size: 0x8, addend: 0x0, symName: __bn_sqrx8x_reduction, symObjAddr: 0x2A77, symBinAddr: 0x367F77, symSize: 0x329 }
-  - { offsetInCU: 0x145, offset: 0xB5B6D, size: 0x8, addend: 0x0, symName: __bn_postx4x_internal, symObjAddr: 0x2DA0, symBinAddr: 0x3682A0, symSize: 0x90 }
-  - { offsetInCU: 0x163, offset: 0xB5B8B, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_scatter5, symObjAddr: 0x2E30, symBinAddr: 0x368330, symSize: 0x30 }
-  - { offsetInCU: 0x178, offset: 0xB5BA0, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_gather5, symObjAddr: 0x2E60, symBinAddr: 0x368360, symSize: 0x27F }
-  - { offsetInCU: 0x10, offset: 0xB5BA2, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ecp_nistz256_neg, symObjAddr: 0x0, symBinAddr: 0x3685E0, symSize: 0x80 }
-  - { offsetInCU: 0x4A, offset: 0xB5BDC, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ecp_nistz256_neg, symObjAddr: 0x0, symBinAddr: 0x3685E0, symSize: 0x80 }
-  - { offsetInCU: 0x64, offset: 0xB5BF6, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_scalar_mul_mont, symObjAddr: 0x80, symBinAddr: 0x368660, symSize: 0x360 }
-  - { offsetInCU: 0x7E, offset: 0xB5C10, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_scalar_sqr_rep_mont, symObjAddr: 0x3E0, symBinAddr: 0x3689C0, symSize: 0x300 }
-  - { offsetInCU: 0x85, offset: 0xB5C17, size: 0x8, addend: 0x0, symName: ecp_nistz256_ord_mul_montx, symObjAddr: 0x6E0, symBinAddr: 0x368CC0, symSize: 0x3C0 }
-  - { offsetInCU: 0x9B, offset: 0xB5C2D, size: 0x8, addend: 0x0, symName: ecp_nistz256_ord_sqr_montx, symObjAddr: 0xAA0, symBinAddr: 0x369080, symSize: 0x320 }
-  - { offsetInCU: 0xB5, offset: 0xB5C47, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_mul_mont, symObjAddr: 0xDC0, symBinAddr: 0x3693A0, symSize: 0xA0 }
-  - { offsetInCU: 0xC4, offset: 0xB5C56, size: 0x8, addend: 0x0, symName: __ecp_nistz256_mul_montq, symObjAddr: 0xE60, symBinAddr: 0x369440, symSize: 0x240 }
-  - { offsetInCU: 0xE1, offset: 0xB5C73, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_sqr_mont, symObjAddr: 0x10A0, symBinAddr: 0x369680, symSize: 0x80 }
-  - { offsetInCU: 0xF0, offset: 0xB5C82, size: 0x8, addend: 0x0, symName: __ecp_nistz256_sqr_montq, symObjAddr: 0x1120, symBinAddr: 0x369700, symSize: 0x1A0 }
-  - { offsetInCU: 0x106, offset: 0xB5C98, size: 0x8, addend: 0x0, symName: __ecp_nistz256_mul_montx, symObjAddr: 0x12C0, symBinAddr: 0x3698A0, symSize: 0x260 }
-  - { offsetInCU: 0x11C, offset: 0xB5CAE, size: 0x8, addend: 0x0, symName: __ecp_nistz256_sqr_montx, symObjAddr: 0x1520, symBinAddr: 0x369B00, symSize: 0x1C0 }
-  - { offsetInCU: 0x142, offset: 0xB5CD4, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ecp_nistz256_select_w5, symObjAddr: 0x16E0, symBinAddr: 0x369CC0, symSize: 0xE0 }
-  - { offsetInCU: 0x158, offset: 0xB5CEA, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ecp_nistz256_select_w7, symObjAddr: 0x17C0, symBinAddr: 0x369DA0, symSize: 0xC0 }
-  - { offsetInCU: 0x162, offset: 0xB5CF4, size: 0x8, addend: 0x0, symName: ecp_nistz256_avx2_select_w5, symObjAddr: 0x1880, symBinAddr: 0x369E60, symSize: 0xC0 }
-  - { offsetInCU: 0x178, offset: 0xB5D0A, size: 0x8, addend: 0x0, symName: ecp_nistz256_avx2_select_w7, symObjAddr: 0x1940, symBinAddr: 0x369F20, symSize: 0xE0 }
-  - { offsetInCU: 0x188, offset: 0xB5D1A, size: 0x8, addend: 0x0, symName: __ecp_nistz256_add_toq, symObjAddr: 0x1A20, symBinAddr: 0x36A000, symSize: 0x60 }
-  - { offsetInCU: 0x1A0, offset: 0xB5D32, size: 0x8, addend: 0x0, symName: __ecp_nistz256_sub_fromq, symObjAddr: 0x1A80, symBinAddr: 0x36A060, symSize: 0x60 }
-  - { offsetInCU: 0x1B1, offset: 0xB5D43, size: 0x8, addend: 0x0, symName: __ecp_nistz256_subq, symObjAddr: 0x1AE0, symBinAddr: 0x36A0C0, symSize: 0x40 }
-  - { offsetInCU: 0x1CC, offset: 0xB5D5E, size: 0x8, addend: 0x0, symName: __ecp_nistz256_mul_by_2q, symObjAddr: 0x1B20, symBinAddr: 0x36A100, symSize: 0x60 }
-  - { offsetInCU: 0x1ED, offset: 0xB5D7F, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_double, symObjAddr: 0x1B80, symBinAddr: 0x36A160, symSize: 0x320 }
-  - { offsetInCU: 0x200, offset: 0xB5D92, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_add, symObjAddr: 0x1EA0, symBinAddr: 0x36A480, symSize: 0x780 }
-  - { offsetInCU: 0x21D, offset: 0xB5DAF, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_add_affine, symObjAddr: 0x2620, symBinAddr: 0x36AC00, symSize: 0x580 }
-  - { offsetInCU: 0x222, offset: 0xB5DB4, size: 0x8, addend: 0x0, symName: __ecp_nistz256_add_tox, symObjAddr: 0x2BA0, symBinAddr: 0x36B180, symSize: 0x60 }
-  - { offsetInCU: 0x23A, offset: 0xB5DCC, size: 0x8, addend: 0x0, symName: __ecp_nistz256_sub_fromx, symObjAddr: 0x2C00, symBinAddr: 0x36B1E0, symSize: 0x60 }
-  - { offsetInCU: 0x24B, offset: 0xB5DDD, size: 0x8, addend: 0x0, symName: __ecp_nistz256_subx, symObjAddr: 0x2C60, symBinAddr: 0x36B240, symSize: 0x60 }
-  - { offsetInCU: 0x266, offset: 0xB5DF8, size: 0x8, addend: 0x0, symName: __ecp_nistz256_mul_by_2x, symObjAddr: 0x2CC0, symBinAddr: 0x36B2A0, symSize: 0x60 }
-  - { offsetInCU: 0x27F, offset: 0xB5E11, size: 0x8, addend: 0x0, symName: ecp_nistz256_point_doublex, symObjAddr: 0x2D20, symBinAddr: 0x36B300, symSize: 0x320 }
-  - { offsetInCU: 0x292, offset: 0xB5E24, size: 0x8, addend: 0x0, symName: ecp_nistz256_point_addx, symObjAddr: 0x3040, symBinAddr: 0x36B620, symSize: 0x760 }
-  - { offsetInCU: 0x2AF, offset: 0xB5E41, size: 0x8, addend: 0x0, symName: ecp_nistz256_point_add_affinex, symObjAddr: 0x37A0, symBinAddr: 0x36BD80, symSize: 0x555 }
-  - { offsetInCU: 0x10, offset: 0xB5E40, size: 0x8, addend: 0x0, symName: _aesni_ctr32_ghash_6x, symObjAddr: 0x0, symBinAddr: 0x36C2E0, symSize: 0x5A0 }
-  - { offsetInCU: 0x3D, offset: 0xB5E6D, size: 0x8, addend: 0x0, symName: _aesni_ctr32_ghash_6x, symObjAddr: 0x0, symBinAddr: 0x36C2E0, symSize: 0x5A0 }
-  - { offsetInCU: 0x61, offset: 0xB5E91, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aesni_gcm_decrypt, symObjAddr: 0x5A0, symBinAddr: 0x36C880, symSize: 0x140 }
-  - { offsetInCU: 0x63, offset: 0xB5E93, size: 0x8, addend: 0x0, symName: _aesni_ctr32_6x, symObjAddr: 0x6E0, symBinAddr: 0x36C9C0, symSize: 0x180 }
-  - { offsetInCU: 0x8D, offset: 0xB5EBD, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aesni_gcm_encrypt, symObjAddr: 0x860, symBinAddr: 0x36CB40, symSize: 0x423 }
-  - { offsetInCU: 0x10, offset: 0xB5EB8, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_init_clmul, symObjAddr: 0x0, symBinAddr: 0x36CF80, symSize: 0x260 }
-  - { offsetInCU: 0x48, offset: 0xB5EF0, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_init_clmul, symObjAddr: 0x0, symBinAddr: 0x36CF80, symSize: 0x260 }
-  - { offsetInCU: 0x5F, offset: 0xB5F07, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_gmult_clmul, symObjAddr: 0x260, symBinAddr: 0x36D1E0, symSize: 0xC0 }
-  - { offsetInCU: 0x75, offset: 0xB5F1D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_ghash_clmul, symObjAddr: 0x320, symBinAddr: 0x36D2A0, symSize: 0x660 }
-  - { offsetInCU: 0x88, offset: 0xB5F30, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_init_avx, symObjAddr: 0x980, symBinAddr: 0x36D900, symSize: 0x1A0 }
-  - { offsetInCU: 0x9F, offset: 0xB5F47, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_ghash_avx, symObjAddr: 0xB20, symBinAddr: 0x36DAA0, symSize: 0x697 }
-  - { offsetInCU: 0x10, offset: 0xB5F46, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha512_block_data_order, symObjAddr: 0x0, symBinAddr: 0x36E140, symSize: 0x1240 }
-  - { offsetInCU: 0x51, offset: 0xB5F87, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha512_block_data_order, symObjAddr: 0x0, symBinAddr: 0x36E140, symSize: 0x1240 }
-  - { offsetInCU: 0x5A, offset: 0xB5F90, size: 0x8, addend: 0x0, symName: sha512_block_data_order_avx, symObjAddr: 0x1240, symBinAddr: 0x36F380, symSize: 0x1176 }
-  - { offsetInCU: 0x10, offset: 0xB5F92, size: 0x8, addend: 0x0, symName: poly_hash_ad_internal, symObjAddr: 0x0, symBinAddr: 0x370500, symSize: 0x200 }
-  - { offsetInCU: 0x44, offset: 0xB5FC6, size: 0x8, addend: 0x0, symName: poly_hash_ad_internal, symObjAddr: 0x0, symBinAddr: 0x370500, symSize: 0x200 }
-  - { offsetInCU: 0x66, offset: 0xB5FE8, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_chacha20_poly1305_open, symObjAddr: 0x200, symBinAddr: 0x370700, symSize: 0x21C0 }
-  - { offsetInCU: 0x7C, offset: 0xB5FFE, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_chacha20_poly1305_seal, symObjAddr: 0x23C0, symBinAddr: 0x3728C0, symSize: 0x1D2D }
-  - { offsetInCU: 0x83, offset: 0xB6005, size: 0x8, addend: 0x0, symName: process_extra_in_trailer, symObjAddr: 0x40ED, symBinAddr: 0x3745ED, symSize: 0x553 }
-  - { offsetInCU: 0x9C, offset: 0xB601E, size: 0x8, addend: 0x0, symName: chacha20_poly1305_open_avx2, symObjAddr: 0x4640, symBinAddr: 0x374B40, symSize: 0x25C0 }
-  - { offsetInCU: 0xB2, offset: 0xB6034, size: 0x8, addend: 0x0, symName: chacha20_poly1305_seal_avx2, symObjAddr: 0x6C00, symBinAddr: 0x377100, symSize: 0x2F01 }
-  - { offsetInCU: 0x10, offset: 0xB6036, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha256_block_data_order, symObjAddr: 0x0, symBinAddr: 0x37A040, symSize: 0x1200 }
-  - { offsetInCU: 0x51, offset: 0xB6077, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha256_block_data_order, symObjAddr: 0x0, symBinAddr: 0x37A040, symSize: 0x1200 }
-  - { offsetInCU: 0x5D, offset: 0xB6083, size: 0x8, addend: 0x0, symName: sha256_block_data_order_shaext, symObjAddr: 0x1200, symBinAddr: 0x37B240, symSize: 0x340 }
-  - { offsetInCU: 0x72, offset: 0xB6098, size: 0x8, addend: 0x0, symName: sha256_block_data_order_ssse3, symObjAddr: 0x1540, symBinAddr: 0x37B580, symSize: 0xEC0 }
-  - { offsetInCU: 0x86, offset: 0xB60AC, size: 0x8, addend: 0x0, symName: sha256_block_data_order_avx, symObjAddr: 0x2400, symBinAddr: 0x37C440, symSize: 0xEF7 }
+  - { offsetInCU: 0x34, offset: 0x795F8, size: 0x8, addend: 0x0, symName: _CanvasNativeVersionString, symObjAddr: 0x0, symBinAddr: 0xA9D000, symSize: 0x0 }
+  - { offsetInCU: 0x69, offset: 0x7962D, size: 0x8, addend: 0x0, symName: _CanvasNativeVersionNumber, symObjAddr: 0x38, symBinAddr: 0xA9D038, symSize: 0x0 }
+  - { offsetInCU: 0x3F, offset: 0x79682, size: 0x8, addend: 0x0, symName: ___swift_memcpy16_8, symObjAddr: 0x40, symBinAddr: 0x1FC0, symSize: 0x10 }
+  - { offsetInCU: 0x53, offset: 0x79696, size: 0x8, addend: 0x0, symName: ___swift_noop_void_return, symObjAddr: 0x50, symBinAddr: 0x1FD0, symSize: 0x10 }
+  - { offsetInCU: 0x67, offset: 0x796AA, size: 0x8, addend: 0x0, symName: '_$sSo6CGSizeVwet', symObjAddr: 0x60, symBinAddr: 0x1FE0, symSize: 0x20 }
+  - { offsetInCU: 0x7B, offset: 0x796BE, size: 0x8, addend: 0x0, symName: '_$sSo6CGSizeVwst', symObjAddr: 0x80, symBinAddr: 0x2000, symSize: 0x30 }
+  - { offsetInCU: 0x8F, offset: 0x796D2, size: 0x8, addend: 0x0, symName: '_$sSo6CGRectVwCP', symObjAddr: 0xD0, symBinAddr: 0x2050, symSize: 0x30 }
+  - { offsetInCU: 0xA3, offset: 0x796E6, size: 0x8, addend: 0x0, symName: ___swift_memcpy32_8, symObjAddr: 0x100, symBinAddr: 0x2080, symSize: 0x20 }
+  - { offsetInCU: 0xB7, offset: 0x796FA, size: 0x8, addend: 0x0, symName: '_$sSo6CGRectVwet', symObjAddr: 0x120, symBinAddr: 0x20A0, symSize: 0x20 }
+  - { offsetInCU: 0xCB, offset: 0x7970E, size: 0x8, addend: 0x0, symName: '_$sSo6CGRectVwst', symObjAddr: 0x140, symBinAddr: 0x20C0, symSize: 0x30 }
+  - { offsetInCU: 0x4F, offset: 0x798F7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC11_WriteQueue33_05178D28796EA758448493B56DC45144LLSo011NSOperationE0CSgvpZ', symObjAddr: 0x30B0, symBinAddr: 0x13639E0, symSize: 0x0 }
+  - { offsetInCU: 0x69, offset: 0x79911, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10_ReadQueue33_05178D28796EA758448493B56DC45144LLSo011NSOperationE0CSgvpZ', symObjAddr: 0x30B8, symBinAddr: 0x13639E8, symSize: 0x0 }
+  - { offsetInCU: 0x9D, offset: 0x79945, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC19getBytesFromUIImageySo13NSMutableDataCSo0G0CFZTo', symObjAddr: 0x10, symBinAddr: 0x2190, symSize: 0x40 }
+  - { offsetInCU: 0xF3, offset: 0x7999B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13createPatternys5Int64VAF_So7UIImageCSStFZTo', symObjAddr: 0x60, symBinAddr: 0x21E0, symSize: 0x60 }
+  - { offsetInCU: 0x144, offset: 0x799EC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC25loadImageAssetWithContextySbs5Int64V_So7UIImageCtFZTo', symObjAddr: 0xD0, symBinAddr: 0x2250, symSize: 0x40 }
+  - { offsetInCU: 0x19F, offset: 0x79A47, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dyys5Int64V_So7UIImageCS2ftFZTo', symObjAddr: 0x120, symBinAddr: 0x22A0, symSize: 0x50 }
+  - { offsetInCU: 0x204, offset: 0x79AAC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dy2dw2dhys5Int64V_So7UIImageCS4ftFZTo', symObjAddr: 0x180, symBinAddr: 0x2300, symSize: 0x60 }
+  - { offsetInCU: 0x27D, offset: 0x79B25, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2sx2sy2sw2sh2dx2dy2dw2dhys5Int64V_So7UIImageCS8ftFZTo', symObjAddr: 0x1F0, symBinAddr: 0x2370, symSize: 0x90 }
+  - { offsetInCU: 0x2DA, offset: 0x79B82, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23initWebGPUWithViewLayerys5Int64VAF_AFs6UInt32VAHtFZTo', symObjAddr: 0x290, symBinAddr: 0x2410, symSize: 0x20 }
+  - { offsetInCU: 0x35C, offset: 0x79C04, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC18initWebGPUWithViewys5Int64VAF_AFs6UInt32VAHtFZTo', symObjAddr: 0x2C0, symBinAddr: 0x2440, symSize: 0x20 }
+  - { offsetInCU: 0x40B, offset: 0x79CB3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14initGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbtFZTo', symObjAddr: 0x350, symBinAddr: 0x24D0, symSize: 0x80 }
+  - { offsetInCU: 0x4D0, offset: 0x79D78, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC20initSharedGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbAFtFZTo', symObjAddr: 0x440, symBinAddr: 0x25C0, symSize: 0x80 }
+  - { offsetInCU: 0x59F, offset: 0x79E47, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC24initGLWithWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbtFZTo', symObjAddr: 0x530, symBinAddr: 0x26B0, symSize: 0x80 }
+  - { offsetInCU: 0x669, offset: 0x79F11, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC26initSharedGLWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbAFtFZTo', symObjAddr: 0x630, symBinAddr: 0x27B0, symSize: 0x90 }
+  - { offsetInCU: 0x701, offset: 0x79FA9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15resize2DContextyys5Int64V_S2ftFZTo', symObjAddr: 0x6D0, symBinAddr: 0x2850, symSize: 0x10 }
+  - { offsetInCU: 0x768, offset: 0x7A010, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14flush2DContextyys5Int64VFZTo', symObjAddr: 0x6F0, symBinAddr: 0x2870, symSize: 0x10 }
+  - { offsetInCU: 0x7BF, offset: 0x7A067, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC7flushGLySbs5Int64VFZTo', symObjAddr: 0x710, symBinAddr: 0x2890, symSize: 0x10 }
+  - { offsetInCU: 0x816, offset: 0x7A0BE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9releaseGLyys5Int64VFZTo', symObjAddr: 0x730, symBinAddr: 0x28B0, symSize: 0x10 }
+  - { offsetInCU: 0x86D, offset: 0x7A115, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC12getGLPointerys5Int64VAFFZTo', symObjAddr: 0x750, symBinAddr: 0x28D0, symSize: 0x10 }
+  - { offsetInCU: 0x8C4, offset: 0x7A16C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC16releaseGLPointeryys5Int64VFZTo', symObjAddr: 0x770, symBinAddr: 0x28F0, symSize: 0x10 }
+  - { offsetInCU: 0x943, offset: 0x7A1EB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15create2DContextys5Int64VAF_s5Int32VAHSbSfA2HSfAHtFZTo', symObjAddr: 0x790, symBinAddr: 0x2910, symSize: 0x40 }
+  - { offsetInCU: 0x9EE, offset: 0x7A296, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23updateGLSurfaceWithViewyys5Int64V_s5Int32VAhFtFZTo', symObjAddr: 0x7E0, symBinAddr: 0x2960, symSize: 0x20 }
+  - { offsetInCU: 0xA61, offset: 0x7A309, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC6test2Dyys5Int64VFZTo', symObjAddr: 0x810, symBinAddr: 0x2990, symSize: 0x10 }
+  - { offsetInCU: 0xAB8, offset: 0x7A360, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13testToDataURLySSs5Int64VFZTo', symObjAddr: 0x880, symBinAddr: 0x2A00, symSize: 0x70 }
+  - { offsetInCU: 0xB43, offset: 0x7A3EB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZTo', symObjAddr: 0xA90, symBinAddr: 0x2C10, symSize: 0xA0 }
+  - { offsetInCU: 0xB94, offset: 0x7A43C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZTo', symObjAddr: 0xD90, symBinAddr: 0x2F10, symSize: 0xA0 }
+  - { offsetInCU: 0xBE5, offset: 0x7A48D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZTo', symObjAddr: 0x10F0, symBinAddr: 0x3270, symSize: 0xA0 }
+  - { offsetInCU: 0xC41, offset: 0x7A4E9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZTo', symObjAddr: 0x1540, symBinAddr: 0x36C0, symSize: 0xD0 }
+  - { offsetInCU: 0xC89, offset: 0x7A531, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC32getPixelsPerInchForCurrentDeviceSSyFZTo', symObjAddr: 0x1620, symBinAddr: 0x37A0, symSize: 0x40 }
+  - { offsetInCU: 0xCE9, offset: 0x7A591, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCACycfcTo', symObjAddr: 0x16B0, symBinAddr: 0x3830, symSize: 0x30 }
+  - { offsetInCU: 0xD3C, offset: 0x7A5E4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC19getBytesFromUIImageySo13NSMutableDataCSo0G0CFZTf4nd_n', symObjAddr: 0x1720, symBinAddr: 0x38A0, symSize: 0x300 }
+  - { offsetInCU: 0xF6C, offset: 0x7A814, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13createPatternys5Int64VAF_So7UIImageCSStFZTf4nnnd_n', symObjAddr: 0x1A20, symBinAddr: 0x3BA0, symSize: 0x260 }
+  - { offsetInCU: 0x1166, offset: 0x7AA0E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC25loadImageAssetWithContextySbs5Int64V_So7UIImageCtFZTf4nnd_n', symObjAddr: 0x1C80, symBinAddr: 0x3E00, symSize: 0xD0 }
+  - { offsetInCU: 0x1263, offset: 0x7AB0B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dyys5Int64V_So7UIImageCS2ftFZTf4nnnnd_n', symObjAddr: 0x1D50, symBinAddr: 0x3ED0, symSize: 0x1B0 }
+  - { offsetInCU: 0x13D8, offset: 0x7AC80, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dy2dw2dhys5Int64V_So7UIImageCS4ftFZTf4nnnnnnd_n', symObjAddr: 0x1F00, symBinAddr: 0x4080, symSize: 0x1D0 }
+  - { offsetInCU: 0x156D, offset: 0x7AE15, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2sx2sy2sw2sh2dx2dy2dw2dhys5Int64V_So7UIImageCS8ftFZTf4nnnnnnnnnnd_n', symObjAddr: 0x20D0, symBinAddr: 0x4250, symSize: 0x200 }
+  - { offsetInCU: 0x1759, offset: 0x7B001, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZTf4nnnd_n', symObjAddr: 0x22D0, symBinAddr: 0x4450, symSize: 0x1D0 }
+  - { offsetInCU: 0x1823, offset: 0x7B0CB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZTf4nnnnd_n', symObjAddr: 0x2660, symBinAddr: 0x47E0, symSize: 0x200 }
+  - { offsetInCU: 0x1904, offset: 0x7B1AC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC32getPixelsPerInchForCurrentDeviceSSyFZTf4d_n', symObjAddr: 0x2860, symBinAddr: 0x49E0, symSize: 0x110 }
+  - { offsetInCU: 0x19AF, offset: 0x7B257, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgACIeyByy_SSSgADIeggg_TR', symObjAddr: 0xB30, symBinAddr: 0x2CB0, symSize: 0x70 }
+  - { offsetInCU: 0x19C7, offset: 0x7B26F, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgSo6NSDataCSgIeyByy_SSSgAFIeggg_TR', symObjAddr: 0xE30, symBinAddr: 0x2FB0, symSize: 0x50 }
+  - { offsetInCU: 0x1A34, offset: 0x7B2DC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCfETo', symObjAddr: 0x1710, symBinAddr: 0x3890, symSize: 0x10 }
+  - { offsetInCU: 0x1ABF, offset: 0x7B367, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCMa', symObjAddr: 0x2970, symBinAddr: 0x4AF0, symSize: 0x20 }
+  - { offsetInCU: 0x1AD3, offset: 0x7B37B, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgACIeyByy_SSSgADIeggg_TRTA', symObjAddr: 0x29B0, symBinAddr: 0x4B30, symSize: 0x10 }
+  - { offsetInCU: 0x1AF2, offset: 0x7B39A, size: 0x8, addend: 0x0, symName: '_$sSo7NSErrorCSg10ObjectiveC8ObjCBoolVIeyByy_ACSbIeggy_TRTA', symObjAddr: 0x29C0, symBinAddr: 0x4B40, symSize: 0x20 }
+  - { offsetInCU: 0x1B1B, offset: 0x7B3C3, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSgSo6NSDataCSgIeyByy_SSSgAFIeggg_TRTA', symObjAddr: 0x29E0, symBinAddr: 0x4B60, symSize: 0x10 }
+  - { offsetInCU: 0x1B2F, offset: 0x7B3D7, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCMa', symObjAddr: 0x29F0, symBinAddr: 0x4B70, symSize: 0x30 }
+  - { offsetInCU: 0x1B43, offset: 0x7B3EB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZyyYbcfU_TA', symObjAddr: 0x2A70, symBinAddr: 0x4BF0, symSize: 0x40 }
+  - { offsetInCU: 0x1B57, offset: 0x7B3FF, size: 0x8, addend: 0x0, symName: _block_copy_helper, symObjAddr: 0x2AB0, symBinAddr: 0x4C30, symSize: 0x20 }
+  - { offsetInCU: 0x1B6B, offset: 0x7B413, size: 0x8, addend: 0x0, symName: _block_destroy_helper, symObjAddr: 0x2AD0, symBinAddr: 0x4C50, symSize: 0x10 }
+  - { offsetInCU: 0x1B7F, offset: 0x7B427, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZyyYbcfU_yyYbcfU0_TA', symObjAddr: 0x2B00, symBinAddr: 0x4C80, symSize: 0x40 }
+  - { offsetInCU: 0x1BB3, offset: 0x7B45B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZyyYbcfU_yyYbcfU0_TA', symObjAddr: 0x2BC0, symBinAddr: 0x4D40, symSize: 0x40 }
+  - { offsetInCU: 0x1BF1, offset: 0x7B499, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZyyYbcfU_yyYbcfU_TA', symObjAddr: 0x2C00, symBinAddr: 0x4D80, symSize: 0x20 }
+  - { offsetInCU: 0x1C25, offset: 0x7B4CD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZyyYbcfU_yyYbcfU_TA', symObjAddr: 0x2CB0, symBinAddr: 0x4E30, symSize: 0x40 }
+  - { offsetInCU: 0x1C59, offset: 0x7B501, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZyyYbcfU_yyYbcfU0_TA', symObjAddr: 0x2D20, symBinAddr: 0x4EA0, symSize: 0x30 }
+  - { offsetInCU: 0x1C95, offset: 0x7B53D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZyyYbcfU_TA', symObjAddr: 0x2DA0, symBinAddr: 0x4F20, symSize: 0x30 }
+  - { offsetInCU: 0x1CA9, offset: 0x7B551, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZyyYbcfU_yyYbcfU_TA', symObjAddr: 0x2DD0, symBinAddr: 0x4F50, symSize: 0x40 }
+  - { offsetInCU: 0x2176, offset: 0x7BA1E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC19getBytesFromUIImageySo13NSMutableDataCSo0G0CFZ', symObjAddr: 0x0, symBinAddr: 0x2180, symSize: 0x10 }
+  - { offsetInCU: 0x2191, offset: 0x7BA39, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x50, symBinAddr: 0x21D0, symSize: 0x10 }
+  - { offsetInCU: 0x21AC, offset: 0x7BA54, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC25loadImageAssetWithContextySbs5Int64V_So7UIImageCtFZ', symObjAddr: 0xC0, symBinAddr: 0x2240, symSize: 0x10 }
+  - { offsetInCU: 0x21CD, offset: 0x7BA75, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dyys5Int64V_So7UIImageCS2ftFZ', symObjAddr: 0x110, symBinAddr: 0x2290, symSize: 0x10 }
+  - { offsetInCU: 0x21E8, offset: 0x7BA90, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2dx2dy2dw2dhys5Int64V_So7UIImageCS4ftFZ', symObjAddr: 0x170, symBinAddr: 0x22F0, symSize: 0x10 }
+  - { offsetInCU: 0x2203, offset: 0x7BAAB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9drawImage7context5image2sx2sy2sw2sh2dx2dy2dw2dhys5Int64V_So7UIImageCS8ftFZ', symObjAddr: 0x1E0, symBinAddr: 0x2360, symSize: 0x10 }
+  - { offsetInCU: 0x221E, offset: 0x7BAC6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23initWebGPUWithViewLayerys5Int64VAF_AFs6UInt32VAHtFZ', symObjAddr: 0x280, symBinAddr: 0x2400, symSize: 0x10 }
+  - { offsetInCU: 0x22AC, offset: 0x7BB54, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC18initWebGPUWithViewys5Int64VAF_AFs6UInt32VAHtFZ', symObjAddr: 0x2B0, symBinAddr: 0x2430, symSize: 0x10 }
+  - { offsetInCU: 0x232B, offset: 0x7BBD3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14initGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbtFZ', symObjAddr: 0x2E0, symBinAddr: 0x2460, symSize: 0x70 }
+  - { offsetInCU: 0x247D, offset: 0x7BD25, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC20initSharedGLWithViewys5Int64VAF_S4bs5Int32VS5bAHSbAFtFZ', symObjAddr: 0x3D0, symBinAddr: 0x2550, symSize: 0x70 }
+  - { offsetInCU: 0x25DB, offset: 0x7BE83, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC24initGLWithWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbtFZ', symObjAddr: 0x4C0, symBinAddr: 0x2640, symSize: 0x70 }
+  - { offsetInCU: 0x2739, offset: 0x7BFE1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC26initSharedGLWidthAndHeightys5Int64Vs5Int32V_AHS4bAHS5bAHSbAFtFZ', symObjAddr: 0x5B0, symBinAddr: 0x2730, symSize: 0x80 }
+  - { offsetInCU: 0x28AD, offset: 0x7C155, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15resize2DContextyys5Int64V_S2ftFZ', symObjAddr: 0x6C0, symBinAddr: 0x2840, symSize: 0x10 }
+  - { offsetInCU: 0x291D, offset: 0x7C1C5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC14flush2DContextyys5Int64VFZ', symObjAddr: 0x6E0, symBinAddr: 0x2860, symSize: 0x10 }
+  - { offsetInCU: 0x2960, offset: 0x7C208, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC7flushGLySbs5Int64VFZ', symObjAddr: 0x700, symBinAddr: 0x2880, symSize: 0x10 }
+  - { offsetInCU: 0x29A5, offset: 0x7C24D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9releaseGLyys5Int64VFZ', symObjAddr: 0x720, symBinAddr: 0x28A0, symSize: 0x10 }
+  - { offsetInCU: 0x29E8, offset: 0x7C290, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC12getGLPointerys5Int64VAFFZ', symObjAddr: 0x740, symBinAddr: 0x28C0, symSize: 0x10 }
+  - { offsetInCU: 0x2A2B, offset: 0x7C2D3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC16releaseGLPointeryys5Int64VFZ', symObjAddr: 0x760, symBinAddr: 0x28E0, symSize: 0x10 }
+  - { offsetInCU: 0x2A6E, offset: 0x7C316, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC15create2DContextys5Int64VAF_s5Int32VAHSbSfA2HSfAHtFZ', symObjAddr: 0x780, symBinAddr: 0x2900, symSize: 0x10 }
+  - { offsetInCU: 0x2B54, offset: 0x7C3FC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC23updateGLSurfaceWithViewyys5Int64V_s5Int32VAhFtFZ', symObjAddr: 0x7D0, symBinAddr: 0x2950, symSize: 0x10 }
+  - { offsetInCU: 0x2BD3, offset: 0x7C47B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC6test2Dyys5Int64VFZ', symObjAddr: 0x800, symBinAddr: 0x2980, symSize: 0x10 }
+  - { offsetInCU: 0x2C16, offset: 0x7C4BE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC13testToDataURLySSs5Int64VFZ', symObjAddr: 0x820, symBinAddr: 0x29A0, symSize: 0x60 }
+  - { offsetInCU: 0x2CD7, offset: 0x7C57F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZ', symObjAddr: 0x8F0, symBinAddr: 0x2A70, symSize: 0x10 }
+  - { offsetInCU: 0x2CEB, offset: 0x7C593, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC9writeFileyySo6NSDataC_SSySSSg_AGtctFZyyYbcfU_', symObjAddr: 0x900, symBinAddr: 0x2A80, symSize: 0x190 }
+  - { offsetInCU: 0x2D8B, offset: 0x7C633, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZ', symObjAddr: 0xBA0, symBinAddr: 0x2D20, symSize: 0x30 }
+  - { offsetInCU: 0x2D9F, offset: 0x7C647, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC8readFileyySS_ySSSg_So6NSDataCSgtctFZyyYbcfU_', symObjAddr: 0xBD0, symBinAddr: 0x2D50, symSize: 0x1C0 }
+  - { offsetInCU: 0x2E89, offset: 0x7C731, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZ', symObjAddr: 0xE80, symBinAddr: 0x3000, symSize: 0x30 }
+  - { offsetInCU: 0x2E9D, offset: 0x7C745, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC10deleteFileyySS_ySo7NSErrorCSg_SbtctFZyyYbcfU_', symObjAddr: 0xEB0, symBinAddr: 0x3030, symSize: 0x240 }
+  - { offsetInCU: 0x2F51, offset: 0x7C7F9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZ', symObjAddr: 0x1190, symBinAddr: 0x3310, symSize: 0x10 }
+  - { offsetInCU: 0x2F65, offset: 0x7C80D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC17handleBase64ImageyySS_S2SySSSg_AEtctFZyyYbcfU_', symObjAddr: 0x11A0, symBinAddr: 0x3320, symSize: 0x3A0 }
+  - { offsetInCU: 0x31FB, offset: 0x7CAA3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersC32getPixelsPerInchForCurrentDeviceSSyFZ', symObjAddr: 0x1610, symBinAddr: 0x3790, symSize: 0x10 }
+  - { offsetInCU: 0x3216, offset: 0x7CABE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCACycfC', symObjAddr: 0x1660, symBinAddr: 0x37E0, symSize: 0x20 }
+  - { offsetInCU: 0x322A, offset: 0x7CAD2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCACycfc', symObjAddr: 0x1680, symBinAddr: 0x3800, symSize: 0x30 }
+  - { offsetInCU: 0x3260, offset: 0x7CB08, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7HelpersCfD', symObjAddr: 0x16E0, symBinAddr: 0x3860, symSize: 0x30 }
+  - { offsetInCU: 0x4F, offset: 0x7CD40, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19shared_context_view33_508084857CA7D194CA72FEB80DD78002LLSo7GLKViewCvpZ', symObjAddr: 0x5C38, symBinAddr: 0x1363A20, symSize: 0x0 }
+  - { offsetInCU: 0x69, offset: 0x7CD5A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15_shared_context33_508084857CA7D194CA72FEB80DD78002LLs5Int64VvpZ', symObjAddr: 0x5C40, symBinAddr: 0x1363A28, symSize: 0x0 }
+  - { offsetInCU: 0x83, offset: 0x7CD74, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5storeSo19NSMutableDictionaryCvpZ', symObjAddr: 0x5C48, symBinAddr: 0x1363A30, symSize: 0x0 }
+  - { offsetInCU: 0x9D, offset: 0x7CD8E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5views33_508084857CA7D194CA72FEB80DD78002LLSo10NSMapTableCySo8NSStringCACGvpZ', symObjAddr: 0x5C50, symBinAddr: 0x1363A38, symSize: 0x0 }
+  - { offsetInCU: 0xAB, offset: 0x7CD9C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19shared_context_view33_508084857CA7D194CA72FEB80DD78002LL_WZ', symObjAddr: 0x0, symBinAddr: 0x5220, symSize: 0x60 }
+  - { offsetInCU: 0xF0, offset: 0x7CDE1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5store_WZ', symObjAddr: 0x60, symBinAddr: 0x5280, symSize: 0x30 }
+  - { offsetInCU: 0x135, offset: 0x7CE26, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5views33_508084857CA7D194CA72FEB80DD78002LL_WZ', symObjAddr: 0xD0, symBinAddr: 0x52F0, symSize: 0x40 }
+  - { offsetInCU: 0x187, offset: 0x7CE78, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC3ptrSvSgvgTo', symObjAddr: 0x1B0, symBinAddr: 0x53D0, symSize: 0x20 }
+  - { offsetInCU: 0x1DD, offset: 0x7CECE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC3ptrSvSgvsTo', symObjAddr: 0x1D0, symBinAddr: 0x53F0, symSize: 0x20 }
+  - { offsetInCU: 0x236, offset: 0x7CF27, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6mtlPtrSvSgvgTo', symObjAddr: 0x1F0, symBinAddr: 0x5410, symSize: 0x20 }
+  - { offsetInCU: 0x28C, offset: 0x7CF7D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6mtlPtrSvSgvsTo', symObjAddr: 0x210, symBinAddr: 0x5430, symSize: 0x20 }
+  - { offsetInCU: 0x2E5, offset: 0x7CFD6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvgTo', symObjAddr: 0x320, symBinAddr: 0x5540, symSize: 0x40 }
+  - { offsetInCU: 0x320, offset: 0x7D011, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvsTo', symObjAddr: 0x390, symBinAddr: 0x55B0, symSize: 0x30 }
+  - { offsetInCU: 0x3AF, offset: 0x7D0A0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8nativeGLs5Int64VvgTo', symObjAddr: 0x5D0, symBinAddr: 0x57F0, symSize: 0x40 }
+  - { offsetInCU: 0x405, offset: 0x7D0F6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8nativeGLs5Int64VvsTo', symObjAddr: 0x640, symBinAddr: 0x5860, symSize: 0x40 }
+  - { offsetInCU: 0x45E, offset: 0x7D14F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13nativeContexts5Int64VvgTo', symObjAddr: 0x680, symBinAddr: 0x58A0, symSize: 0x40 }
+  - { offsetInCU: 0x4B4, offset: 0x7D1A5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13nativeContexts5Int64VvsTo', symObjAddr: 0x6F0, symBinAddr: 0x5910, symSize: 0x40 }
+  - { offsetInCU: 0x50D, offset: 0x7D1FE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15native2DContexts5Int64VvgTo', symObjAddr: 0x730, symBinAddr: 0x5950, symSize: 0x20 }
+  - { offsetInCU: 0x563, offset: 0x7D254, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15native2DContexts5Int64VvsTo', symObjAddr: 0x750, symBinAddr: 0x5970, symSize: 0x20 }
+  - { offsetInCU: 0x5BC, offset: 0x7D2AD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7mtlViewSo7MTKViewCvgTo', symObjAddr: 0x770, symBinAddr: 0x5990, symSize: 0x20 }
+  - { offsetInCU: 0x614, offset: 0x7D305, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7mtlViewSo7MTKViewCvsTo', symObjAddr: 0x790, symBinAddr: 0x59B0, symSize: 0x30 }
+  - { offsetInCU: 0x66D, offset: 0x7D35E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7glkViewAA0A7GLKViewCvgTo', symObjAddr: 0x7C0, symBinAddr: 0x59E0, symSize: 0x20 }
+  - { offsetInCU: 0x6C5, offset: 0x7D3B6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7glkViewAA0A7GLKViewCvsTo', symObjAddr: 0x7E0, symBinAddr: 0x5A00, symSize: 0x30 }
+  - { offsetInCU: 0x71E, offset: 0x7D40F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC4is2DSbvgTo', symObjAddr: 0x810, symBinAddr: 0x5A30, symSize: 0x20 }
+  - { offsetInCU: 0x774, offset: 0x7D465, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC4is2DSbvsTo', symObjAddr: 0x830, symBinAddr: 0x5A50, symSize: 0x10 }
+  - { offsetInCU: 0x7CD, offset: 0x7D4BE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7isMetalSbvgTo', symObjAddr: 0x840, symBinAddr: 0x5A60, symSize: 0x20 }
+  - { offsetInCU: 0x823, offset: 0x7D514, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC7isMetalSbvsTo', symObjAddr: 0x860, symBinAddr: 0x5A80, symSize: 0x10 }
+  - { offsetInCU: 0x866, offset: 0x7D557, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18drawingBufferWidthSivgTo', symObjAddr: 0x870, symBinAddr: 0x5A90, symSize: 0x30 }
+  - { offsetInCU: 0x898, offset: 0x7D589, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19drawingBufferHeightSivgTo', symObjAddr: 0x960, symBinAddr: 0x5B80, symSize: 0x30 }
+  - { offsetInCU: 0x8E0, offset: 0x7D5D1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5widthSfvgTo', symObjAddr: 0xA50, symBinAddr: 0x5C70, symSize: 0x30 }
+  - { offsetInCU: 0x948, offset: 0x7D639, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6heightSfvgTo', symObjAddr: 0xAB0, symBinAddr: 0x5CD0, symSize: 0x30 }
+  - { offsetInCU: 0x9E7, offset: 0x7D6D8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11initContextyySS_S4bs5Int32VS5btFTo', symObjAddr: 0xB20, symBinAddr: 0x5D40, symSize: 0xD0 }
+  - { offsetInCU: 0xA96, offset: 0x7D787, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17initWebGPUContextyys5Int64VFTo', symObjAddr: 0xDA0, symBinAddr: 0x5FC0, symSize: 0x30 }
+  - { offsetInCU: 0xB46, offset: 0x7D837, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC015initContextWithE10AttributesyySS_S4bs5Int32VS5btFTo', symObjAddr: 0x1760, symBinAddr: 0x6980, symSize: 0xD0 }
+  - { offsetInCU: 0xBB0, offset: 0x7D8A1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15create2DContextys5Int64VSb_S3bs5Int32VS5bAHtFTo', symObjAddr: 0x1A70, symBinAddr: 0x6C90, symSize: 0x90 }
+  - { offsetInCU: 0xBED, offset: 0x7D8DE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11forceLayoutyy12CoreGraphics7CGFloatV_AGtFTo', symObjAddr: 0x1BF0, symBinAddr: 0x6E10, symSize: 0x100 }
+  - { offsetInCU: 0xC6B, offset: 0x7D95C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8snapshotySo7UIImageCSgSbFTo', symObjAddr: 0x1DC0, symBinAddr: 0x6FE0, symSize: 0x40 }
+  - { offsetInCU: 0xC9E, offset: 0x7D98F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8rendererAA9NSCRenderCSgvgTo', symObjAddr: 0x1E00, symBinAddr: 0x7020, symSize: 0x20 }
+  - { offsetInCU: 0xCF8, offset: 0x7D9E9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8rendererAA9NSCRenderCSgvsTo', symObjAddr: 0x1E20, symBinAddr: 0x7040, symSize: 0x30 }
+  - { offsetInCU: 0xD53, offset: 0x7DA44, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6renderSbyFTo', symObjAddr: 0x1E90, symBinAddr: 0x70B0, symSize: 0x40 }
+  - { offsetInCU: 0xDE9, offset: 0x7DADA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13context2DTestyys5Int64VFTo', symObjAddr: 0x1F10, symBinAddr: 0x7130, symSize: 0x60 }
+  - { offsetInCU: 0xEAE, offset: 0x7DB9F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC22context2DTestToDataURLySSs5Int64VFTo', symObjAddr: 0x1FD0, symBinAddr: 0x71F0, symSize: 0xA0 }
+  - { offsetInCU: 0xF3B, offset: 0x7DC2C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC23enterBackgroundListeneryycSgvsTo', symObjAddr: 0x20C0, symBinAddr: 0x72E0, symSize: 0x70 }
+  - { offsetInCU: 0xF9D, offset: 0x7DC8E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC20becomeActiveListeneryycSgvsTo', symObjAddr: 0x21D0, symBinAddr: 0x73F0, symSize: 0x70 }
+  - { offsetInCU: 0xFFA, offset: 0x7DCEB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvgTo', symObjAddr: 0x2240, symBinAddr: 0x7460, symSize: 0xB0 }
+  - { offsetInCU: 0x104A, offset: 0x7DD3B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvsTo', symObjAddr: 0x23B0, symBinAddr: 0x75D0, symSize: 0x90 }
+  - { offsetInCU: 0x10DA, offset: 0x7DDCB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5coderACSgSo7NSCoderC_tcfcTo', symObjAddr: 0x3160, symBinAddr: 0x8380, symSize: 0x30 }
+  - { offsetInCU: 0x112F, offset: 0x7DE20, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5frameACSo6CGRectV_tcfcTo', symObjAddr: 0x3D20, symBinAddr: 0x8F40, symSize: 0x30 }
+  - { offsetInCU: 0x1162, offset: 0x7DE53, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvgTo', symObjAddr: 0x3D50, symBinAddr: 0x8F70, symSize: 0x20 }
+  - { offsetInCU: 0x11BA, offset: 0x7DEAB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvsTo', symObjAddr: 0x3D70, symBinAddr: 0x8F90, symSize: 0x30 }
+  - { offsetInCU: 0x1228, offset: 0x7DF19, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13readyListenerAA0cE0_pSgvgTo', symObjAddr: 0x3E20, symBinAddr: 0x9040, symSize: 0x30 }
+  - { offsetInCU: 0x1282, offset: 0x7DF73, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13readyListenerAA0cE0_pSgvsTo', symObjAddr: 0x3E50, symBinAddr: 0x9070, symSize: 0x30 }
+  - { offsetInCU: 0x12E2, offset: 0x7DFD3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11setListeneryyAA0cE0_pSgFTo', symObjAddr: 0x3EB0, symBinAddr: 0x90D0, symSize: 0x30 }
+  - { offsetInCU: 0x1426, offset: 0x7E117, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC14layoutSubviewsyyFTo', symObjAddr: 0x4290, symBinAddr: 0x94B0, symSize: 0x30 }
+  - { offsetInCU: 0x1459, offset: 0x7E14A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCfDTo', symObjAddr: 0x45B0, symBinAddr: 0x97D0, symSize: 0x20 }
+  - { offsetInCU: 0x1494, offset: 0x7E185, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC21getBoundingClientRectyySo6UIViewC_SvtFZTo', symObjAddr: 0x46A0, symBinAddr: 0x98C0, symSize: 0x30 }
+  - { offsetInCU: 0x14C7, offset: 0x7E1B8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC14shared_context33_508084857CA7D194CA72FEB80DD78002LLs5Int64VvgZTf4d_n', symObjAddr: 0x50D0, symBinAddr: 0xA2F0, symSize: 0x2A0 }
+  - { offsetInCU: 0x162F, offset: 0x7E320, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC21getBoundingClientRectyySo6UIViewC_SvtFZTf4nnd_n', symObjAddr: 0x5440, symBinAddr: 0xA660, symSize: 0xC0 }
+  - { offsetInCU: 0x184B, offset: 0x7E53C, size: 0x8, addend: 0x0, symName: '_$sIeg_IeyB_TR', symObjAddr: 0x2090, symBinAddr: 0x72B0, symSize: 0x30 }
+  - { offsetInCU: 0x1863, offset: 0x7E554, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_So8NSStringCABIeyByy_TR', symObjAddr: 0x2340, symBinAddr: 0x7560, symSize: 0x70 }
+  - { offsetInCU: 0x187B, offset: 0x7E56C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvpACTK', symObjAddr: 0x24A0, symBinAddr: 0x76C0, symSize: 0x90 }
+  - { offsetInCU: 0x18B3, offset: 0x7E5A4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvpACTk', symObjAddr: 0x2530, symBinAddr: 0x7750, symSize: 0xC0 }
+  - { offsetInCU: 0x18F3, offset: 0x7E5E4, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCytIegnnr_SSABIeggg_TR', symObjAddr: 0x25F0, symBinAddr: 0x7810, symSize: 0x70 }
+  - { offsetInCU: 0x19A3, offset: 0x7E694, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCfETo', symObjAddr: 0x45D0, symBinAddr: 0x97F0, symSize: 0xC0 }
+  - { offsetInCU: 0x19D3, offset: 0x7E6C4, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_SgWOy', symObjAddr: 0x46D0, symBinAddr: 0x98F0, symSize: 0x20 }
+  - { offsetInCU: 0x19E7, offset: 0x7E6D8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCMa', symObjAddr: 0x46F0, symBinAddr: 0x9910, symSize: 0x20 }
+  - { offsetInCU: 0x19FB, offset: 0x7E6EC, size: 0x8, addend: 0x0, symName: '_$ss29getContiguousArrayStorageType3fors01_bcD0CyxGmxm_tlFSo18NSLayoutConstraintC_Tgm5', symObjAddr: 0x4710, symBinAddr: 0x9930, symSize: 0x60 }
+  - { offsetInCU: 0x1C02, offset: 0x7E8F3, size: 0x8, addend: 0x0, symName: ___swift_instantiateConcreteTypeFromMangledName, symObjAddr: 0x5370, symBinAddr: 0xA590, symSize: 0x40 }
+  - { offsetInCU: 0x1C16, offset: 0x7E907, size: 0x8, addend: 0x0, symName: '_$sypSgWOh', symObjAddr: 0x53B0, symBinAddr: 0xA5D0, symSize: 0x30 }
+  - { offsetInCU: 0x1C2A, offset: 0x7E91B, size: 0x8, addend: 0x0, symName: ___swift_project_boxed_opaque_existential_0, symObjAddr: 0x53E0, symBinAddr: 0xA600, symSize: 0x30 }
+  - { offsetInCU: 0x1C3E, offset: 0x7E92F, size: 0x8, addend: 0x0, symName: ___swift_destroy_boxed_opaque_existential_0, symObjAddr: 0x5410, symBinAddr: 0xA630, symSize: 0x30 }
+  - { offsetInCU: 0x1C5D, offset: 0x7E94E, size: 0x8, addend: 0x0, symName: '_$sSo8NSStringCSo19UIGestureRecognizerCIeyByy_SSADIeggg_TRTA', symObjAddr: 0x59A0, symBinAddr: 0xABC0, symSize: 0x40 }
+  - { offsetInCU: 0x1C86, offset: 0x7E977, size: 0x8, addend: 0x0, symName: _block_copy_helper, symObjAddr: 0x59E0, symBinAddr: 0xAC00, symSize: 0x20 }
+  - { offsetInCU: 0x1C9A, offset: 0x7E98B, size: 0x8, addend: 0x0, symName: _block_destroy_helper, symObjAddr: 0x5A00, symBinAddr: 0xAC20, symSize: 0x10 }
+  - { offsetInCU: 0x1CAE, offset: 0x7E99F, size: 0x8, addend: 0x0, symName: '_$sIeg_SgWOe', symObjAddr: 0x5A10, symBinAddr: 0xAC30, symSize: 0x20 }
+  - { offsetInCU: 0x1CCD, offset: 0x7E9BE, size: 0x8, addend: 0x0, symName: '_$sIeyB_Ieg_TRTA', symObjAddr: 0x5A30, symBinAddr: 0xAC50, symSize: 0x10 }
+  - { offsetInCU: 0x1CF6, offset: 0x7E9E7, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCytIegnnr_SSABIeggg_TRTA', symObjAddr: 0x5A60, symBinAddr: 0xAC80, symSize: 0x20 }
+  - { offsetInCU: 0x1D15, offset: 0x7EA06, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_SSABytIegnnr_TRTA', symObjAddr: 0x5A80, symBinAddr: 0xACA0, symSize: 0x30 }
+  - { offsetInCU: 0x1D3E, offset: 0x7EA2F, size: 0x8, addend: 0x0, symName: '_$sypWOb', symObjAddr: 0x5AB0, symBinAddr: 0xACD0, symSize: 0x20 }
+  - { offsetInCU: 0x1D52, offset: 0x7EA43, size: 0x8, addend: 0x0, symName: '_$sypWOc', symObjAddr: 0x5B00, symBinAddr: 0xAD20, symSize: 0x30 }
+  - { offsetInCU: 0x1FD7, offset: 0x7ECC8, size: 0x8, addend: 0x0, symName: '_$sSD17dictionaryLiteralSDyxq_Gx_q_td_tcfCSS_ypTgm5Tf4g_n', symObjAddr: 0x4FE0, symBinAddr: 0xA200, symSize: 0xF0 }
+  - { offsetInCU: 0x2469, offset: 0x7F15A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvg', symObjAddr: 0x360, symBinAddr: 0x5580, symSize: 0x30 }
+  - { offsetInCU: 0x249A, offset: 0x7F18B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvs', symObjAddr: 0x3C0, symBinAddr: 0x55E0, symSize: 0xE0 }
+  - { offsetInCU: 0x24E4, offset: 0x7F1D5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvM', symObjAddr: 0x4A0, symBinAddr: 0x56C0, symSize: 0x50 }
+  - { offsetInCU: 0x2507, offset: 0x7F1F8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC9autoScaleSbvM.resume.0', symObjAddr: 0x4F0, symBinAddr: 0x5710, symSize: 0xE0 }
+  - { offsetInCU: 0x2548, offset: 0x7F239, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8nativeGLs5Int64Vvg', symObjAddr: 0x610, symBinAddr: 0x5830, symSize: 0x30 }
+  - { offsetInCU: 0x259E, offset: 0x7F28F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13nativeContexts5Int64Vvg', symObjAddr: 0x6C0, symBinAddr: 0x58E0, symSize: 0x30 }
+  - { offsetInCU: 0x270A, offset: 0x7F3FB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18drawingBufferWidthSivg', symObjAddr: 0x8A0, symBinAddr: 0x5AC0, symSize: 0xC0 }
+  - { offsetInCU: 0x282F, offset: 0x7F520, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC19drawingBufferHeightSivg', symObjAddr: 0x990, symBinAddr: 0x5BB0, symSize: 0xC0 }
+  - { offsetInCU: 0x2975, offset: 0x7F666, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5widthSfvg', symObjAddr: 0xA80, symBinAddr: 0x5CA0, symSize: 0x30 }
+  - { offsetInCU: 0x29BB, offset: 0x7F6AC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6heightSfvg', symObjAddr: 0xAE0, symBinAddr: 0x5D00, symSize: 0x30 }
+  - { offsetInCU: 0x29ED, offset: 0x7F6DE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11initContextyySS_S4bs5Int32VS5btF', symObjAddr: 0xB10, symBinAddr: 0x5D30, symSize: 0x10 }
+  - { offsetInCU: 0x2B6A, offset: 0x7F85B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17initWebGPUContextyys5Int64VF', symObjAddr: 0xBF0, symBinAddr: 0x5E10, symSize: 0x1B0 }
+  - { offsetInCU: 0x2F4D, offset: 0x7FC3E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC015initContextWithE10AttributesyySS_S4bs5Int32VS5btF', symObjAddr: 0xDD0, symBinAddr: 0x5FF0, symSize: 0x990 }
+  - { offsetInCU: 0x36DB, offset: 0x803CC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC15create2DContextys5Int64VSb_S3bs5Int32VS5bAHtF', symObjAddr: 0x1830, symBinAddr: 0x6A50, symSize: 0x240 }
+  - { offsetInCU: 0x3B67, offset: 0x80858, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11forceLayoutyy12CoreGraphics7CGFloatV_AGtF', symObjAddr: 0x1B00, symBinAddr: 0x6D20, symSize: 0xF0 }
+  - { offsetInCU: 0x3BF6, offset: 0x808E7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC8snapshotySo7UIImageCSgSbF', symObjAddr: 0x1CF0, symBinAddr: 0x6F10, symSize: 0xD0 }
+  - { offsetInCU: 0x3D4F, offset: 0x80A40, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6renderSbyF', symObjAddr: 0x1E50, symBinAddr: 0x7070, symSize: 0x40 }
+  - { offsetInCU: 0x3DD3, offset: 0x80AC4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC13context2DTestyys5Int64VF', symObjAddr: 0x1ED0, symBinAddr: 0x70F0, symSize: 0x40 }
+  - { offsetInCU: 0x3EF2, offset: 0x80BE3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC22context2DTestToDataURLySSs5Int64VF', symObjAddr: 0x1F70, symBinAddr: 0x7190, symSize: 0x60 }
+  - { offsetInCU: 0x3FE8, offset: 0x80CD9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvg', symObjAddr: 0x22F0, symBinAddr: 0x7510, symSize: 0x50 }
+  - { offsetInCU: 0x4032, offset: 0x80D23, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvs', symObjAddr: 0x2440, symBinAddr: 0x7660, symSize: 0x60 }
+  - { offsetInCU: 0x4059, offset: 0x80D4A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvM', symObjAddr: 0x2660, symBinAddr: 0x7880, symSize: 0x40 }
+  - { offsetInCU: 0x407F, offset: 0x80D70, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC18touchEventListenerySS_So19UIGestureRecognizerCtcSgvM.resume.0', symObjAddr: 0x26A0, symBinAddr: 0x78C0, symSize: 0x10 }
+  - { offsetInCU: 0x4141, offset: 0x80E32, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5coderACSgSo7NSCoderC_tcfc', symObjAddr: 0x26B0, symBinAddr: 0x78D0, symSize: 0xAB0 }
+  - { offsetInCU: 0x4366, offset: 0x81057, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5frameACSo6CGRectV_tcfC', symObjAddr: 0x3190, symBinAddr: 0x83B0, symSize: 0x80 }
+  - { offsetInCU: 0x438F, offset: 0x81080, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC5frameACSo6CGRectV_tcfc', symObjAddr: 0x3210, symBinAddr: 0x8430, symSize: 0xB10 }
+  - { offsetInCU: 0x45D5, offset: 0x812C6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC17ignoreTouchEventsSbvW', symObjAddr: 0x3DA0, symBinAddr: 0x8FC0, symSize: 0x80 }
+  - { offsetInCU: 0x46CB, offset: 0x813BC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC11setListeneryyAA0cE0_pSgF', symObjAddr: 0x3E80, symBinAddr: 0x90A0, symSize: 0x30 }
+  - { offsetInCU: 0x4767, offset: 0x81458, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC6resize33_508084857CA7D194CA72FEB80DD78002LLyyF', symObjAddr: 0x3EE0, symBinAddr: 0x9100, symSize: 0x110 }
+  - { offsetInCU: 0x49B8, offset: 0x816A9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC14layoutSubviewsyyF', symObjAddr: 0x3FF0, symBinAddr: 0x9210, symSize: 0x2A0 }
+  - { offsetInCU: 0x4C14, offset: 0x81905, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasCfD', symObjAddr: 0x42C0, symBinAddr: 0x94E0, symSize: 0x2F0 }
+  - { offsetInCU: 0x4CA2, offset: 0x81993, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCCanvasC21getBoundingClientRectyySo6UIViewC_SvtFZ', symObjAddr: 0x4690, symBinAddr: 0x98B0, symSize: 0x10 }
+  - { offsetInCU: 0x4CCA, offset: 0x819BB, size: 0x8, addend: 0x0, symName: '_$ss22__RawDictionaryStorageC4findys10_HashTableV6BucketV6bucket_Sb5foundtxSHRzlFSS_Tg5', symObjAddr: 0x4770, symBinAddr: 0x9990, symSize: 0x60 }
+  - { offsetInCU: 0x4D24, offset: 0x81A15, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV7_insert2at3key5valueys10_HashTableV6BucketV_xnq_ntFSS_ypTg5', symObjAddr: 0x47D0, symBinAddr: 0x99F0, symSize: 0x60 }
+  - { offsetInCU: 0x4D90, offset: 0x81A81, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV12mutatingFind_8isUniques10_HashTableV6BucketV6bucket_Sb5foundtx_SbtFSS_ypTg5', symObjAddr: 0x4830, symBinAddr: 0x9A50, symSize: 0xB0 }
+  - { offsetInCU: 0x4DCD, offset: 0x81ABE, size: 0x8, addend: 0x0, symName: '_$ss22__RawDictionaryStorageC4find_9hashValues10_HashTableV6BucketV6bucket_Sb5foundtx_SitSHRzlFSS_Tg5', symObjAddr: 0x48E0, symBinAddr: 0x9B00, symSize: 0xE0 }
+  - { offsetInCU: 0x4E38, offset: 0x81B29, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV4copyyyFSS_ypTg5', symObjAddr: 0x49C0, symBinAddr: 0x9BE0, symSize: 0x260 }
+  - { offsetInCU: 0x4EE0, offset: 0x81BD1, size: 0x8, addend: 0x0, symName: '_$ss17_NativeDictionaryV20_copyOrMoveAndResize8capacity12moveElementsySi_SbtFSS_ypTg5', symObjAddr: 0x4C20, symBinAddr: 0x9E40, symSize: 0x3C0 }
+  - { offsetInCU: 0x27, offset: 0x81E25, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative7GLUtilsCfD', symObjAddr: 0x0, symBinAddr: 0xAE00, symSize: 0x20 }
+  - { offsetInCU: 0x62, offset: 0x81E60, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative7GLUtilsCMa', symObjAddr: 0x20, symBinAddr: 0xAE20, symSize: 0x14 }
+  - { offsetInCU: 0x1AF, offset: 0x81FAD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative7GLUtilsCfD', symObjAddr: 0x0, symBinAddr: 0xAE00, symSize: 0x20 }
+  - { offsetInCU: 0x65, offset: 0x8203A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8mPrograms6UInt32VvgTo', symObjAddr: 0x0, symBinAddr: 0xAE40, symSize: 0x10 }
+  - { offsetInCU: 0xBB, offset: 0x82090, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8mPrograms6UInt32VvsTo', symObjAddr: 0x10, symBinAddr: 0xAE50, symSize: 0x10 }
+  - { offsetInCU: 0x114, offset: 0x820E9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3rbos6UInt32VvgTo', symObjAddr: 0x20, symBinAddr: 0xAE60, symSize: 0x40 }
+  - { offsetInCU: 0x16A, offset: 0x8213F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3rbos6UInt32VvsTo', symObjAddr: 0x60, symBinAddr: 0xAEA0, symSize: 0x40 }
+  - { offsetInCU: 0x1C3, offset: 0x82198, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3fbos6UInt32VvgTo', symObjAddr: 0xA0, symBinAddr: 0xAEE0, symSize: 0x40 }
+  - { offsetInCU: 0x219, offset: 0x821EE, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3fbos6UInt32VvsTo', symObjAddr: 0xE0, symBinAddr: 0xAF20, symSize: 0x40 }
+  - { offsetInCU: 0x272, offset: 0x82247, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC5widthSivgTo', symObjAddr: 0x120, symBinAddr: 0xAF60, symSize: 0x20 }
+  - { offsetInCU: 0x2C8, offset: 0x8229D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC5widthSivsTo', symObjAddr: 0x140, symBinAddr: 0xAF80, symSize: 0x20 }
+  - { offsetInCU: 0x321, offset: 0x822F6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC6heightSivgTo', symObjAddr: 0x160, symBinAddr: 0xAFA0, symSize: 0x20 }
+  - { offsetInCU: 0x377, offset: 0x8234C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC6heightSivsTo', symObjAddr: 0x180, symBinAddr: 0xAFC0, symSize: 0x20 }
+  - { offsetInCU: 0x3D0, offset: 0x823A5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC2abs6UInt32VvgTo', symObjAddr: 0x1A0, symBinAddr: 0xAFE0, symSize: 0x40 }
+  - { offsetInCU: 0x426, offset: 0x823FB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC2abs6UInt32VvsTo', symObjAddr: 0x1E0, symBinAddr: 0xB020, symSize: 0x40 }
+  - { offsetInCU: 0x47F, offset: 0x82454, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3poss5Int32VvgTo', symObjAddr: 0x220, symBinAddr: 0xB060, symSize: 0x10 }
+  - { offsetInCU: 0x4D5, offset: 0x824AA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC3poss5Int32VvsTo', symObjAddr: 0x230, symBinAddr: 0xB070, symSize: 0x10 }
+  - { offsetInCU: 0x52E, offset: 0x82503, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10samplerPoss5Int32VvgTo', symObjAddr: 0x240, symBinAddr: 0xB080, symSize: 0x10 }
+  - { offsetInCU: 0x584, offset: 0x82559, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10samplerPoss5Int32VvsTo', symObjAddr: 0x250, symBinAddr: 0xB090, symSize: 0x10 }
+  - { offsetInCU: 0x5DD, offset: 0x825B2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9vextexBufSaySfGvgTo', symObjAddr: 0x260, symBinAddr: 0xB0A0, symSize: 0x40 }
+  - { offsetInCU: 0x633, offset: 0x82608, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9vextexBufSaySfGvsTo', symObjAddr: 0x2A0, symBinAddr: 0xB0E0, symSize: 0x40 }
+  - { offsetInCU: 0x676, offset: 0x8264B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13SIZE_OF_FLOATSivgZTo', symObjAddr: 0x2E0, symBinAddr: 0xB120, symSize: 0x10 }
+  - { offsetInCU: 0x692, offset: 0x82667, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13VERTEX_SHADERSSvgZTo', symObjAddr: 0x2F0, symBinAddr: 0xB130, symSize: 0x30 }
+  - { offsetInCU: 0x6C4, offset: 0x82699, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7surfaceSo9IOSurfaceCSgvgTo', symObjAddr: 0x320, symBinAddr: 0xB160, symSize: 0x20 }
+  - { offsetInCU: 0x71C, offset: 0x826F1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7surfaceSo9IOSurfaceCSgvsTo', symObjAddr: 0x340, symBinAddr: 0xB180, symSize: 0x30 }
+  - { offsetInCU: 0x775, offset: 0x8274A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8pixelBufs9UnmanagedVySo11CVBufferRefaGSgvgTo', symObjAddr: 0x490, symBinAddr: 0xB2D0, symSize: 0x20 }
+  - { offsetInCU: 0x7CB, offset: 0x827A0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC8pixelBufs9UnmanagedVySo11CVBufferRefaGSgvsTo', symObjAddr: 0x4B0, symBinAddr: 0xB2F0, symSize: 0x20 }
+  - { offsetInCU: 0x83A, offset: 0x8280F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCACycfcTo', symObjAddr: 0x680, symBinAddr: 0xB480, symSize: 0x20 }
+  - { offsetInCU: 0x86C, offset: 0x82841, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7destroyyyFTo', symObjAddr: 0x7E0, symBinAddr: 0xB5E0, symSize: 0x30 }
+  - { offsetInCU: 0x8C4, offset: 0x82899, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10texImage2Dyys5Int32V_A4fA9NSCCanvasCAHSbtFTo', symObjAddr: 0x830, symBinAddr: 0xB630, symSize: 0x80 }
+  - { offsetInCU: 0x928, offset: 0x828FD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9drawFrame6buffer5width6height14internalFormat6format10flipYWebGLySo11CVBufferRefa_S2is5Int32VANSbtFTo', symObjAddr: 0x8B0, symBinAddr: 0xB6B0, symSize: 0x80 }
+  - { offsetInCU: 0x9CA, offset: 0x8299F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13createSurfaceyyFTo', symObjAddr: 0xCE0, symBinAddr: 0xBAE0, symSize: 0x30 }
+  - { offsetInCU: 0xAB4, offset: 0x82A89, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCMa', symObjAddr: 0x660, symBinAddr: 0xB460, symSize: 0x20 }
+  - { offsetInCU: 0xB33, offset: 0x82B08, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCfETo', symObjAddr: 0xD40, symBinAddr: 0xBB40, symSize: 0x60 }
+  - { offsetInCU: 0x1271, offset: 0x83246, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCACycfC', symObjAddr: 0x4D0, symBinAddr: 0xB310, symSize: 0x20 }
+  - { offsetInCU: 0x128B, offset: 0x83260, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCACycfc', symObjAddr: 0x4F0, symBinAddr: 0xB330, symSize: 0x130 }
+  - { offsetInCU: 0x12BB, offset: 0x83290, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC7destroyyyF', symObjAddr: 0x6A0, symBinAddr: 0xB4A0, symSize: 0x140 }
+  - { offsetInCU: 0x1474, offset: 0x83449, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10texImage2Dyys5Int32V_A4fA9NSCCanvasCAHSbtF', symObjAddr: 0x810, symBinAddr: 0xB610, symSize: 0x20 }
+  - { offsetInCU: 0x1525, offset: 0x834FA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC13createSurfaceyyF', symObjAddr: 0x930, symBinAddr: 0xB730, symSize: 0x3B0 }
+  - { offsetInCU: 0x18BB, offset: 0x83890, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderCfD', symObjAddr: 0xD10, symBinAddr: 0xBB10, symSize: 0x30 }
+  - { offsetInCU: 0x19B4, offset: 0x83989, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC10texImage2Dyys5Int32V_A4fA9NSCCanvasCAHSbtFTf4ddnndnndn_n', symObjAddr: 0xDA0, symBinAddr: 0xBBA0, symSize: 0x720 }
+  - { offsetInCU: 0x231C, offset: 0x842F1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative9NSCRenderC9drawFrame6buffer5width6height14internalFormat6format10flipYWebGLySo11CVBufferRefa_S2is5Int32VANSbtFTf4nnnnndn_n', symObjAddr: 0x1520, symBinAddr: 0xC320, symSize: 0x7EC }
+  - { offsetInCU: 0x10C, offset: 0x84E9A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC6target6actionAEypSg_10ObjectiveC8SelectorVSgtcfcTo', symObjAddr: 0x1120, symBinAddr: 0xDBF0, symSize: 0x60 }
+  - { offsetInCU: 0x19C, offset: 0x84F2A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerCfETo', symObjAddr: 0x11A0, symBinAddr: 0xDC70, symSize: 0x20 }
+  - { offsetInCU: 0x1CB, offset: 0x84F59, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC6handleyySo19UIGestureRecognizerCFTo', symObjAddr: 0x11C0, symBinAddr: 0xDC90, symSize: 0x10 }
+  - { offsetInCU: 0x368, offset: 0x850F6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerCACycfcTo', symObjAddr: 0x1A40, symBinAddr: 0xE510, symSize: 0x30 }
+  - { offsetInCU: 0x5E4, offset: 0x85372, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerCfETo', symObjAddr: 0x1AC0, symBinAddr: 0xE590, symSize: 0x60 }
+  - { offsetInCU: 0x613, offset: 0x853A1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerCMa', symObjAddr: 0x1B20, symBinAddr: 0xE5F0, symSize: 0x20 }
+  - { offsetInCU: 0x627, offset: 0x853B5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerCMa', symObjAddr: 0x1B40, symBinAddr: 0xE610, symSize: 0x20 }
+  - { offsetInCU: 0x63B, offset: 0x853C9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwCP', symObjAddr: 0x1B60, symBinAddr: 0xE630, symSize: 0x30 }
+  - { offsetInCU: 0x64F, offset: 0x853DD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwxx', symObjAddr: 0x1B90, symBinAddr: 0xE660, symSize: 0x10 }
+  - { offsetInCU: 0x663, offset: 0x853F1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwcp', symObjAddr: 0x1BA0, symBinAddr: 0xE670, symSize: 0x30 }
+  - { offsetInCU: 0x677, offset: 0x85405, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwca', symObjAddr: 0x1BD0, symBinAddr: 0xE6A0, symSize: 0x50 }
+  - { offsetInCU: 0x68B, offset: 0x85419, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwta', symObjAddr: 0x1C40, symBinAddr: 0xE6F0, symSize: 0x40 }
+  - { offsetInCU: 0x69F, offset: 0x8542D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwet', symObjAddr: 0x1C80, symBinAddr: 0xE730, symSize: 0x40 }
+  - { offsetInCU: 0x6B3, offset: 0x85441, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVwst', symObjAddr: 0x1CC0, symBinAddr: 0xE770, symSize: 0x50 }
+  - { offsetInCU: 0x6C7, offset: 0x85455, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC7PointerVMa', symObjAddr: 0x1D10, symBinAddr: 0xE7C0, symSize: 0x10 }
+  - { offsetInCU: 0x6DB, offset: 0x85469, size: 0x8, addend: 0x0, symName: '_$sypSgWOc', symObjAddr: 0x1D20, symBinAddr: 0xE7D0, symSize: 0x40 }
+  - { offsetInCU: 0x6EF, offset: 0x8547D, size: 0x8, addend: 0x0, symName: '_$sSo7UITouchCSo8NSObjectCSH10ObjectiveCWl', symObjAddr: 0x1E30, symBinAddr: 0xE810, symSize: 0x50 }
+  - { offsetInCU: 0x703, offset: 0x85491, size: 0x8, addend: 0x0, symName: '_$sSh8IteratorV8_VariantOyx__GSHRzlWOe', symObjAddr: 0x1E80, symBinAddr: 0xE860, symSize: 0x20 }
+  - { offsetInCU: 0x761, offset: 0x854EF, size: 0x8, addend: 0x0, symName: '_$sSSSo19UIGestureRecognizerCIeggg_SgWOe', symObjAddr: 0x21A0, symBinAddr: 0xEB80, symSize: 0x14 }
+  - { offsetInCU: 0xCB4, offset: 0x85A42, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC12touchesBegan_4withyShySo7UITouchCG_So7UIEventCtF', symObjAddr: 0x0, symBinAddr: 0xCB10, symSize: 0x630 }
+  - { offsetInCU: 0xF39, offset: 0x85CC7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC12touchesMoved_4withyShySo7UITouchCG_So7UIEventCtF', symObjAddr: 0x650, symBinAddr: 0xD160, symSize: 0xE0 }
+  - { offsetInCU: 0xFB8, offset: 0x85D46, size: 0x8, addend: 0x0, symName: '_$sSa6remove2atxSi_tF12CanvasNative15NSCTouchHandlerC7PointerV_Tg5', symObjAddr: 0x800, symBinAddr: 0xD2F0, symSize: 0xB0 }
+  - { offsetInCU: 0x102A, offset: 0x85DB8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC22TouchGestureRecognizerC6target6actionAEypSg_10ObjectiveC8SelectorVSgtcfc', symObjAddr: 0x1030, symBinAddr: 0xDB00, symSize: 0xF0 }
+  - { offsetInCU: 0x1179, offset: 0x85F07, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC6onMove33_044DDF836BDB3B89B481C6F58BB6EF6BLLyySo19UIGestureRecognizerC_ShySo7UITouchCGSgtF', symObjAddr: 0x1590, symBinAddr: 0xE060, symSize: 0x4B0 }
+  - { offsetInCU: 0x18C2, offset: 0x86650, size: 0x8, addend: 0x0, symName: '_$ss12_ArrayBufferV20_consumeAndCreateNewAByxGyF12CanvasNative15NSCTouchHandlerC7PointerV_Tg5', symObjAddr: 0x1EA0, symBinAddr: 0xE880, symSize: 0x20 }
+  - { offsetInCU: 0x195A, offset: 0x866E8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative15NSCTouchHandlerC6canvasAcA9NSCCanvasC_tcfcTf4gn_n', symObjAddr: 0x1EC0, symBinAddr: 0xE8A0, symSize: 0x1F0 }
+  - { offsetInCU: 0x27, offset: 0x868B1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC14FAILED_TO_LOADSSvgZTo', symObjAddr: 0x0, symBinAddr: 0xEBA0, symSize: 0x30 }
+  - { offsetInCU: 0x4B, offset: 0x868D5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queueSo012OS_dispatch_E0CvpZ', symObjAddr: 0x2A0, symBinAddr: 0x1363D48, symSize: 0x0 }
+  - { offsetInCU: 0x65, offset: 0x868EF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC14FAILED_TO_LOADSSvgZTo', symObjAddr: 0x0, symBinAddr: 0xEBA0, symSize: 0x30 }
+  - { offsetInCU: 0x98, offset: 0x86922, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queueSo012OS_dispatch_E0CvgZTo', symObjAddr: 0x160, symBinAddr: 0xED00, symSize: 0x30 }
+  - { offsetInCU: 0x104, offset: 0x8698E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCACycfcTo', symObjAddr: 0x200, symBinAddr: 0xEDA0, symSize: 0x30 }
+  - { offsetInCU: 0x158, offset: 0x869E2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queue_WZ', symObjAddr: 0x30, symBinAddr: 0xEBD0, symSize: 0xF0 }
+  - { offsetInCU: 0x183, offset: 0x86A0D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCMa', symObjAddr: 0x1E0, symBinAddr: 0xED80, symSize: 0x20 }
+  - { offsetInCU: 0x197, offset: 0x86A21, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCfETo', symObjAddr: 0x260, symBinAddr: 0xEE00, symSize: 0x10 }
+  - { offsetInCU: 0x1C2, offset: 0x86A4C, size: 0x8, addend: 0x0, symName: '_$sSo17OS_dispatch_queueCMa', symObjAddr: 0x270, symBinAddr: 0xEE10, symSize: 0x2F }
+  - { offsetInCU: 0x34A, offset: 0x86BD4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapC5queueSo012OS_dispatch_E0CvgZ', symObjAddr: 0x120, symBinAddr: 0xECC0, symSize: 0x40 }
+  - { offsetInCU: 0x38A, offset: 0x86C14, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCACycfC', symObjAddr: 0x190, symBinAddr: 0xED30, symSize: 0x20 }
+  - { offsetInCU: 0x39E, offset: 0x86C28, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCACycfc', symObjAddr: 0x1B0, symBinAddr: 0xED50, symSize: 0x30 }
+  - { offsetInCU: 0x3DA, offset: 0x86C64, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative14NSCImageBitmapCfD', symObjAddr: 0x230, symBinAddr: 0xEDD0, symSize: 0x30 }
+  - { offsetInCU: 0x2B, offset: 0x86CB2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC18createTextureCacheSo017CVOpenGLESTextureF3RefaSgyFZ', symObjAddr: 0x0, symBinAddr: 0xEE40, symSize: 0xA0 }
+  - { offsetInCU: 0x66, offset: 0x86CED, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC18createTextureCacheSo017CVOpenGLESTextureF3RefaSgyFZTo', symObjAddr: 0xA0, symBinAddr: 0xEEE0, symSize: 0xA0 }
+  - { offsetInCU: 0xF9, offset: 0x86D80, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11createImageySo11CVBufferRefaSgSo022CVOpenGLESTextureCacheG0a_AFSo012CFDictionaryG0aSgs6UInt32Vs5Int32VA2p2NSitFZTo', symObjAddr: 0x1D0, symBinAddr: 0xF010, symSize: 0x100 }
+  - { offsetInCU: 0x1AD, offset: 0x86E34, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11setupRenderAA9NSCRenderCyFZTo', symObjAddr: 0x300, symBinAddr: 0xF140, symSize: 0x30 }
+  - { offsetInCU: 0x22D, offset: 0x86EB4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC9drawFrameyySo8AVPlayerC_So0F15ItemVideoOutputCSo6CGSizeVAA9NSCRenderCs5Int32VANSbtFZTo', symObjAddr: 0x340, symBinAddr: 0xF180, symSize: 0x90 }
+  - { offsetInCU: 0x2A6, offset: 0x86F2D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11writeToFileyySo6NSDataC_SStKFZTo', symObjAddr: 0x4E0, symBinAddr: 0xF320, symSize: 0x140 }
+  - { offsetInCU: 0x345, offset: 0x86FCC, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCACycfcTo', symObjAddr: 0x670, symBinAddr: 0xF4B0, symSize: 0x30 }
+  - { offsetInCU: 0x398, offset: 0x8701F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC9drawFrameyySo8AVPlayerC_So0F15ItemVideoOutputCSo6CGSizeVAA9NSCRenderCs5Int32VANSbtFZTf4nnnnnndd_n', symObjAddr: 0x6D0, symBinAddr: 0xF510, symSize: 0x170 }
+  - { offsetInCU: 0x50B, offset: 0x87192, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC7getFile33_F00B23A4165DD6ABFCD23C8811C7DF43LLyS2SKFZTf4nd_g', symObjAddr: 0x840, symBinAddr: 0xF680, symSize: 0x310 }
+  - { offsetInCU: 0x5EA, offset: 0x87271, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCMa', symObjAddr: 0xB50, symBinAddr: 0xF990, symSize: 0x20 }
+  - { offsetInCU: 0x5FE, offset: 0x87285, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOAEs5ErrorAAWl', symObjAddr: 0xB70, symBinAddr: 0xF9B0, symSize: 0x30 }
+  - { offsetInCU: 0x612, offset: 0x87299, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwCP', symObjAddr: 0xBA0, symBinAddr: 0xF9E0, symSize: 0x30 }
+  - { offsetInCU: 0x626, offset: 0x872AD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwxx', symObjAddr: 0xBD0, symBinAddr: 0xFA10, symSize: 0x10 }
+  - { offsetInCU: 0x63A, offset: 0x872C1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwca', symObjAddr: 0xBE0, symBinAddr: 0xFA20, symSize: 0x40 }
+  - { offsetInCU: 0x64E, offset: 0x872D5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwta', symObjAddr: 0xC30, symBinAddr: 0xFA60, symSize: 0x30 }
+  - { offsetInCU: 0x662, offset: 0x872E9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwet', symObjAddr: 0xC60, symBinAddr: 0xFA90, symSize: 0x40 }
+  - { offsetInCU: 0x676, offset: 0x872FD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwst', symObjAddr: 0xCA0, symBinAddr: 0xFAD0, symSize: 0x40 }
+  - { offsetInCU: 0x68A, offset: 0x87311, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwug', symObjAddr: 0xCE0, symBinAddr: 0xFB10, symSize: 0x10 }
+  - { offsetInCU: 0x69E, offset: 0x87325, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwup', symObjAddr: 0xCF0, symBinAddr: 0xFB20, symSize: 0x10 }
+  - { offsetInCU: 0x6B2, offset: 0x87339, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOwui', symObjAddr: 0xD00, symBinAddr: 0xFB30, symSize: 0x10 }
+  - { offsetInCU: 0x6C6, offset: 0x8734D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOMa', symObjAddr: 0xD10, symBinAddr: 0xFB40, symSize: 0x10 }
+  - { offsetInCU: 0x74E, offset: 0x873D5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP7_domainSSvgTW', symObjAddr: 0x3D0, symBinAddr: 0xF210, symSize: 0x10 }
+  - { offsetInCU: 0x76A, offset: 0x873F1, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP5_codeSivgTW', symObjAddr: 0x3E0, symBinAddr: 0xF220, symSize: 0x10 }
+  - { offsetInCU: 0x786, offset: 0x8740D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP9_userInfoyXlSgvgTW', symObjAddr: 0x3F0, symBinAddr: 0xF230, symSize: 0x10 }
+  - { offsetInCU: 0x7A2, offset: 0x87429, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC8NSCErrorOs5ErrorAAsAFP19_getEmbeddedNSErroryXlSgyFTW', symObjAddr: 0x400, symBinAddr: 0xF240, symSize: 0x10 }
+  - { offsetInCU: 0xA56, offset: 0x876DD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC18createTextureCacheSo017CVOpenGLESTextureF3RefaSgyFZ', symObjAddr: 0x0, symBinAddr: 0xEE40, symSize: 0xA0 }
+  - { offsetInCU: 0xAEC, offset: 0x87773, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11createImageySo11CVBufferRefaSgSo022CVOpenGLESTextureCacheG0a_AFSo012CFDictionaryG0aSgs6UInt32Vs5Int32VA2p2NSitFZ', symObjAddr: 0x140, symBinAddr: 0xEF80, symSize: 0x90 }
+  - { offsetInCU: 0xC71, offset: 0x878F8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11setupRenderAA9NSCRenderCyFZ', symObjAddr: 0x2D0, symBinAddr: 0xF110, symSize: 0x30 }
+  - { offsetInCU: 0xCBB, offset: 0x87942, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC9drawFrameyySo8AVPlayerC_So0F15ItemVideoOutputCSo6CGSizeVAA9NSCRenderCs5Int32VANSbtFZ', symObjAddr: 0x330, symBinAddr: 0xF170, symSize: 0x10 }
+  - { offsetInCU: 0xCDD, offset: 0x87964, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsC11writeToFileyySo6NSDataC_SStKFZ', symObjAddr: 0x410, symBinAddr: 0xF250, symSize: 0xD0 }
+  - { offsetInCU: 0xD8D, offset: 0x87A14, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCACycfC', symObjAddr: 0x620, symBinAddr: 0xF460, symSize: 0x20 }
+  - { offsetInCU: 0xDA1, offset: 0x87A28, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCACycfc', symObjAddr: 0x640, symBinAddr: 0xF480, symSize: 0x30 }
+  - { offsetInCU: 0xDD7, offset: 0x87A5E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative5UtilsCfD', symObjAddr: 0x6A0, symBinAddr: 0xF4E0, symSize: 0x30 }
+  - { offsetInCU: 0x27, offset: 0x87B7E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x0, symBinAddr: 0xFB60, symSize: 0x10 }
+  - { offsetInCU: 0x71, offset: 0x87BC8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZTo', symObjAddr: 0x10, symBinAddr: 0xFB70, symSize: 0x60 }
+  - { offsetInCU: 0xF6, offset: 0x87C4D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS2ftFZTo', symObjAddr: 0x80, symBinAddr: 0xFBE0, symSize: 0x50 }
+  - { offsetInCU: 0x193, offset: 0x87CEA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS4ftFZTo', symObjAddr: 0xE0, symBinAddr: 0xFC40, symSize: 0x60 }
+  - { offsetInCU: 0x25C, offset: 0x87DB3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS8ftFZTo', symObjAddr: 0x150, symBinAddr: 0xFCB0, symSize: 0x90 }
+  - { offsetInCU: 0x339, offset: 0x87E90, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCACycfcTo', symObjAddr: 0x230, symBinAddr: 0xFD90, symSize: 0x30 }
+  - { offsetInCU: 0x38D, offset: 0x87EE4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCMa', symObjAddr: 0x290, symBinAddr: 0xFDF0, symSize: 0x14 }
+  - { offsetInCU: 0x4FD, offset: 0x88054, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC13createPatternys5Int64VAF_So7UIImageCSStFZ', symObjAddr: 0x0, symBinAddr: 0xFB60, symSize: 0x10 }
+  - { offsetInCU: 0x5A0, offset: 0x880F7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS2ftFZ', symObjAddr: 0x70, symBinAddr: 0xFBD0, symSize: 0x10 }
+  - { offsetInCU: 0x640, offset: 0x88197, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS4ftFZ', symObjAddr: 0xD0, symBinAddr: 0xFC30, symSize: 0x10 }
+  - { offsetInCU: 0x703, offset: 0x8825A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DC9drawImageyys5Int64V_So7UIImageCS8ftFZ', symObjAddr: 0x140, symBinAddr: 0xFCA0, symSize: 0x10 }
+  - { offsetInCU: 0x80F, offset: 0x88366, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCACycfC', symObjAddr: 0x1E0, symBinAddr: 0xFD40, symSize: 0x20 }
+  - { offsetInCU: 0x823, offset: 0x8837A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCACycfc', symObjAddr: 0x200, symBinAddr: 0xFD60, symSize: 0x30 }
+  - { offsetInCU: 0x859, offset: 0x883B0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative27NSCCanvasRenderingContext2DCfD', symObjAddr: 0x260, symBinAddr: 0xFDC0, symSize: 0x30 }
+  - { offsetInCU: 0x27, offset: 0x883FA, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC10texImage2Dyys5Int64V_s5Int32VA4HSpys5UInt8VGSuSo6CGSizeVSbtFZ', symObjAddr: 0x0, symBinAddr: 0xFE10, symSize: 0x30 }
+  - { offsetInCU: 0xA9, offset: 0x8847C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC10texImage2Dyys5Int64V_s5Int32VA4HSpys5UInt8VGSuSo6CGSizeVSbtFZTo', symObjAddr: 0x30, symBinAddr: 0xFE40, symSize: 0x50 }
+  - { offsetInCU: 0x1A6, offset: 0x88579, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC13texSubImage2Dyys5Int64V_s5Int32VA5HSpys5UInt8VGSuSo6CGSizeVSbtFZTo', symObjAddr: 0xC0, symBinAddr: 0xFED0, symSize: 0x50 }
+  - { offsetInCU: 0x289, offset: 0x8865C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCACycfcTo', symObjAddr: 0x180, symBinAddr: 0xFF90, symSize: 0x30 }
+  - { offsetInCU: 0x2DD, offset: 0x886B0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCMa', symObjAddr: 0x160, symBinAddr: 0xFF70, symSize: 0x20 }
+  - { offsetInCU: 0x487, offset: 0x8885A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC10texImage2Dyys5Int64V_s5Int32VA4HSpys5UInt8VGSuSo6CGSizeVSbtFZ', symObjAddr: 0x0, symBinAddr: 0xFE10, symSize: 0x30 }
+  - { offsetInCU: 0x5DD, offset: 0x889B0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextC13texSubImage2Dyys5Int64V_s5Int32VA5HSpys5UInt8VGSuSo6CGSizeVSbtFZ', symObjAddr: 0x80, symBinAddr: 0xFE90, symSize: 0x40 }
+  - { offsetInCU: 0x725, offset: 0x88AF8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCACycfC', symObjAddr: 0x110, symBinAddr: 0xFF20, symSize: 0x20 }
+  - { offsetInCU: 0x739, offset: 0x88B0C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCACycfc', symObjAddr: 0x130, symBinAddr: 0xFF40, symSize: 0x30 }
+  - { offsetInCU: 0x76F, offset: 0x88B42, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative24NSCWebGLRenderingContextCfD', symObjAddr: 0x1B0, symBinAddr: 0xFFC0, symSize: 0x2B }
+  - { offsetInCU: 0x61, offset: 0x88BC6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7isDirtySbvgTo', symObjAddr: 0x10, symBinAddr: 0x10000, symSize: 0x20 }
+  - { offsetInCU: 0xB7, offset: 0x88C1C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7isDirtySbvsTo', symObjAddr: 0x30, symBinAddr: 0x10020, symSize: 0x10 }
+  - { offsetInCU: 0x110, offset: 0x88C75, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC6canvasAA9NSCCanvasCSgvgTo', symObjAddr: 0x40, symBinAddr: 0x10030, symSize: 0x40 }
+  - { offsetInCU: 0x168, offset: 0x88CCD, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC6canvasAA9NSCCanvasCSgvsTo', symObjAddr: 0xC0, symBinAddr: 0x100B0, symSize: 0x40 }
+  - { offsetInCU: 0x1C3, offset: 0x88D28, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC3fbos6UInt32VvgTo', symObjAddr: 0x100, symBinAddr: 0x100F0, symSize: 0x10 }
+  - { offsetInCU: 0x219, offset: 0x88D7E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC3fbos6UInt32VvsTo', symObjAddr: 0x110, symBinAddr: 0x10100, symSize: 0x10 }
+  - { offsetInCU: 0x272, offset: 0x88DD7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCACycfcTo', symObjAddr: 0x1C0, symBinAddr: 0x101B0, symSize: 0x80 }
+  - { offsetInCU: 0x2CA, offset: 0x88E2F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frameACSo6CGRectV_tcfcTo', symObjAddr: 0x300, symBinAddr: 0x102F0, symSize: 0xA0 }
+  - { offsetInCU: 0x32C, offset: 0x88E91, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5coderACSgSo7NSCoderC_tcfcTo', symObjAddr: 0x470, symBinAddr: 0x10460, symSize: 0x30 }
+  - { offsetInCU: 0x35E, offset: 0x88EC3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC12bindDrawableyyFTo', symObjAddr: 0x520, symBinAddr: 0x10490, symSize: 0xA0 }
+  - { offsetInCU: 0x3DF, offset: 0x88F44, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC14deleteDrawableyyFTo', symObjAddr: 0x600, symBinAddr: 0x10530, symSize: 0x60 }
+  - { offsetInCU: 0x44F, offset: 0x88FB4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7glkView_6drawInySo0C0C_So6CGRectVtFTo', symObjAddr: 0x670, symBinAddr: 0x105A0, symSize: 0x50 }
+  - { offsetInCU: 0x4C1, offset: 0x89026, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frame7contextACSo6CGRectV_So11EAGLContextCtcfcTo', symObjAddr: 0x780, symBinAddr: 0x106B0, symSize: 0x30 }
+  - { offsetInCU: 0x535, offset: 0x8909A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCMa', symObjAddr: 0x1A0, symBinAddr: 0x10190, symSize: 0x20 }
+  - { offsetInCU: 0x55F, offset: 0x890C4, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCfETo', symObjAddr: 0x7D0, symBinAddr: 0x10700, symSize: 0x20 }
+  - { offsetInCU: 0x65D, offset: 0x891C2, size: 0x8, addend: 0x0, symName: '_$sSo7GLKViewC12CanvasNativeE16snapshotWithDatayy10Foundation0F0VFTo', symObjAddr: 0xAF0, symBinAddr: 0x10A20, symSize: 0x80 }
+  - { offsetInCU: 0x69B, offset: 0x89200, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC7isDirtySbvgTo', symObjAddr: 0xB70, symBinAddr: 0x10AA0, symSize: 0x20 }
+  - { offsetInCU: 0x6F1, offset: 0x89256, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC7isDirtySbvsTo', symObjAddr: 0xB90, symBinAddr: 0x10AC0, symSize: 0x10 }
+  - { offsetInCU: 0x74A, offset: 0x892AF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC8rendererAA9NSCCanvasCSgvgTo', symObjAddr: 0xBA0, symBinAddr: 0x10AD0, symSize: 0x20 }
+  - { offsetInCU: 0x7A2, offset: 0x89307, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC8rendererAA9NSCCanvasCSgvsTo', symObjAddr: 0xBC0, symBinAddr: 0x10AF0, symSize: 0x20 }
+  - { offsetInCU: 0x7FD, offset: 0x89362, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvgTo', symObjAddr: 0xBE0, symBinAddr: 0x10B10, symSize: 0x40 }
+  - { offsetInCU: 0x853, offset: 0x893B8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvsTo', symObjAddr: 0xC50, symBinAddr: 0x10B80, symSize: 0x40 }
+  - { offsetInCU: 0x8E6, offset: 0x8944B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCACycfcTo', symObjAddr: 0xDC0, symBinAddr: 0x10CF0, symSize: 0x80 }
+  - { offsetInCU: 0x93E, offset: 0x894A3, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5frameACSo6CGRectV_tcfcTo', symObjAddr: 0xF90, symBinAddr: 0x10EC0, symSize: 0xA0 }
+  - { offsetInCU: 0x9A0, offset: 0x89505, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5coderACSgSo7NSCoderC_tcfcTo', symObjAddr: 0x10E0, symBinAddr: 0x11010, symSize: 0x30 }
+  - { offsetInCU: 0x9D2, offset: 0x89537, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC11deviceScaleSfyFTo', symObjAddr: 0x1110, symBinAddr: 0x11040, symSize: 0xB0 }
+  - { offsetInCU: 0xA53, offset: 0x895B8, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC4drawyySo6CGRectVFTo', symObjAddr: 0x11D0, symBinAddr: 0x110F0, symSize: 0x30 }
+  - { offsetInCU: 0xAB1, offset: 0x89616, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCfETo', symObjAddr: 0x1250, symBinAddr: 0x11170, symSize: 0x20 }
+  - { offsetInCU: 0xC63, offset: 0x897C8, size: 0x8, addend: 0x0, symName: '_$ss22_ContiguousArrayBufferV19_uninitializedCount15minimumCapacityAByxGSi_SitcfC12CanvasNative15NSCTouchHandlerC7PointerV_Tgm5', symObjAddr: 0x1470, symBinAddr: 0x112E0, symSize: 0x80 }
+  - { offsetInCU: 0xCE6, offset: 0x8984B, size: 0x8, addend: 0x0, symName: '_$ss22_ContiguousArrayBufferV19_uninitializedCount15minimumCapacityAByxGSi_SitcfCs5UInt8V_Tgm5', symObjAddr: 0x1570, symBinAddr: 0x11360, symSize: 0x70 }
+  - { offsetInCU: 0xD6A, offset: 0x898CF, size: 0x8, addend: 0x0, symName: '_$s10Foundation4DataV15_RepresentationOWOy', symObjAddr: 0x1750, symBinAddr: 0x11540, symSize: 0x40 }
+  - { offsetInCU: 0xD7E, offset: 0x898E3, size: 0x8, addend: 0x0, symName: '_$s10Foundation4DataV15_RepresentationOWOe', symObjAddr: 0x1790, symBinAddr: 0x11580, symSize: 0x40 }
+  - { offsetInCU: 0xD92, offset: 0x898F7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCMa', symObjAddr: 0x17D0, symBinAddr: 0x115C0, symSize: 0x20 }
+  - { offsetInCU: 0xE6C, offset: 0x899D1, size: 0x8, addend: 0x0, symName: '_$sSaySayxGqd__c7ElementQyd__RszSTRd__lufCs5UInt8V_10Foundation4DataVTgm5Tf4g_n', symObjAddr: 0x1650, symBinAddr: 0x11440, symSize: 0x100 }
+  - { offsetInCU: 0x112B, offset: 0x89C90, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC6canvasAA9NSCCanvasCSgvg', symObjAddr: 0x80, symBinAddr: 0x10070, symSize: 0x40 }
+  - { offsetInCU: 0x11A8, offset: 0x89D0D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewCACycfc', symObjAddr: 0x120, symBinAddr: 0x10110, symSize: 0x80 }
+  - { offsetInCU: 0x11EF, offset: 0x89D54, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frameACSo6CGRectV_tcfc', symObjAddr: 0x240, symBinAddr: 0x10230, symSize: 0xC0 }
+  - { offsetInCU: 0x1251, offset: 0x89DB6, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5coderACSgSo7NSCoderC_tcfc', symObjAddr: 0x3A0, symBinAddr: 0x10390, symSize: 0xD0 }
+  - { offsetInCU: 0x12DA, offset: 0x89E3F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7glkView_6drawInySo0C0C_So6CGRectVtF', symObjAddr: 0x660, symBinAddr: 0x10590, symSize: 0x10 }
+  - { offsetInCU: 0x12FB, offset: 0x89E60, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frame7contextACSo6CGRectV_So11EAGLContextCtcfC', symObjAddr: 0x6C0, symBinAddr: 0x105F0, symSize: 0x90 }
+  - { offsetInCU: 0x130F, offset: 0x89E74, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC5frame7contextACSo6CGRectV_So11EAGLContextCtcfc', symObjAddr: 0x750, symBinAddr: 0x10680, symSize: 0x30 }
+  - { offsetInCU: 0x1428, offset: 0x89F8D, size: 0x8, addend: 0x0, symName: '_$sSo7GLKViewC12CanvasNativeE16snapshotWithDatayy10Foundation0F0VF', symObjAddr: 0x7F0, symBinAddr: 0x10720, symSize: 0x300 }
+  - { offsetInCU: 0x17D2, offset: 0x8A337, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvg', symObjAddr: 0xC20, symBinAddr: 0x10B50, symSize: 0x30 }
+  - { offsetInCU: 0x180F, offset: 0x8A374, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvs', symObjAddr: 0xC90, symBinAddr: 0x10BC0, symSize: 0x40 }
+  - { offsetInCU: 0x1836, offset: 0x8A39B, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvM', symObjAddr: 0xCD0, symBinAddr: 0x10C00, symSize: 0x40 }
+  - { offsetInCU: 0x185B, offset: 0x8A3C0, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC18ignorePixelScalingSbvM.resume.0', symObjAddr: 0xD10, symBinAddr: 0x10C40, symSize: 0x10 }
+  - { offsetInCU: 0x1882, offset: 0x8A3E7, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCACycfC', symObjAddr: 0xD20, symBinAddr: 0x10C50, symSize: 0x20 }
+  - { offsetInCU: 0x1896, offset: 0x8A3FB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewCACycfc', symObjAddr: 0xD40, symBinAddr: 0x10C70, symSize: 0x80 }
+  - { offsetInCU: 0x18DD, offset: 0x8A442, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5frameACSo6CGRectV_tcfc', symObjAddr: 0xED0, symBinAddr: 0x10E00, symSize: 0xC0 }
+  - { offsetInCU: 0x193A, offset: 0x8A49F, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC5coderACSgSo7NSCoderC_tcfc', symObjAddr: 0x1030, symBinAddr: 0x10F60, symSize: 0xB0 }
+  - { offsetInCU: 0x19D6, offset: 0x8A53B, size: 0x8, addend: 0x0, symName: '_$ss12_ArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtF12CanvasNative15NSCTouchHandlerC7PointerV_Tg5', symObjAddr: 0x1270, symBinAddr: 0x11190, symSize: 0xB0 }
+  - { offsetInCU: 0x1AB8, offset: 0x8A61D, size: 0x8, addend: 0x0, symName: '_$ss12_ArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtFs5UInt8V_Tg5', symObjAddr: 0x13D0, symBinAddr: 0x11240, symSize: 0xA0 }
+  - { offsetInCU: 0x1BC4, offset: 0x8A729, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7GLKViewC7glkView_6drawInySo0C0C_So6CGRectVtFTf4ddn_n', symObjAddr: 0x15E0, symBinAddr: 0x113D0, symSize: 0x70 }
+  - { offsetInCU: 0x1CBF, offset: 0x8A824, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative0A7CPUViewC4drawyySo6CGRectVFTf4dn_n', symObjAddr: 0x17F0, symBinAddr: 0x115E0, symSize: 0x410 }
+  - { offsetInCU: 0x4F, offset: 0x8AC3C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC5queue33_7ED578B0ED4B2B6F6887A622A7B49AA3LLSo012OS_dispatch_E0CvpZ', symObjAddr: 0x980, symBinAddr: 0x1363E90, symSize: 0x0 }
+  - { offsetInCU: 0x5D, offset: 0x8AC4A, size: 0x8, addend: 0x0, symName: '_$sIegh_IeyBh_TR', symObjAddr: 0x0, symBinAddr: 0x11BE0, symSize: 0x30 }
+  - { offsetInCU: 0x75, offset: 0x8AC62, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC5queue33_7ED578B0ED4B2B6F6887A622A7B49AA3LL_WZ', symObjAddr: 0x30, symBinAddr: 0x11C10, symSize: 0xF0 }
+  - { offsetInCU: 0xBC, offset: 0x8ACA9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF4SyncySbs5Int64V_So7UIImageCtFZTo', symObjAddr: 0x130, symBinAddr: 0x11D10, symSize: 0x40 }
+  - { offsetInCU: 0x130, offset: 0x8AD1D, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZTo', symObjAddr: 0x3C0, symBinAddr: 0x11FA0, symSize: 0x80 }
+  - { offsetInCU: 0x18F, offset: 0x8AD7C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCACycfcTo', symObjAddr: 0x490, symBinAddr: 0x12070, symSize: 0x30 }
+  - { offsetInCU: 0x1E2, offset: 0x8ADCF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZTf4nnnd_n', symObjAddr: 0x500, symBinAddr: 0x120E0, symSize: 0x200 }
+  - { offsetInCU: 0x261, offset: 0x8AE4E, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCfETo', symObjAddr: 0x4F0, symBinAddr: 0x120D0, symSize: 0x10 }
+  - { offsetInCU: 0x29D, offset: 0x8AE8A, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCMa', symObjAddr: 0x700, symBinAddr: 0x122E0, symSize: 0x20 }
+  - { offsetInCU: 0x2BC, offset: 0x8AEA9, size: 0x8, addend: 0x0, symName: '_$s10ObjectiveC8ObjCBoolVIeyBy_SbIegy_TRTA', symObjAddr: 0x740, symBinAddr: 0x12320, symSize: 0x20 }
+  - { offsetInCU: 0x2E5, offset: 0x8AED2, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_TA', symObjAddr: 0x790, symBinAddr: 0x12370, symSize: 0x20 }
+  - { offsetInCU: 0x2F9, offset: 0x8AEE6, size: 0x8, addend: 0x0, symName: _block_copy_helper, symObjAddr: 0x7B0, symBinAddr: 0x12390, symSize: 0x20 }
+  - { offsetInCU: 0x30D, offset: 0x8AEFA, size: 0x8, addend: 0x0, symName: _block_destroy_helper, symObjAddr: 0x7D0, symBinAddr: 0x123B0, symSize: 0x10 }
+  - { offsetInCU: 0x321, offset: 0x8AF0E, size: 0x8, addend: 0x0, symName: '_$sSay8Dispatch0A13WorkItemFlagsVGMa', symObjAddr: 0x850, symBinAddr: 0x123F0, symSize: 0x50 }
+  - { offsetInCU: 0x335, offset: 0x8AF22, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_yyScMYccfU0_TA', symObjAddr: 0x8D0, symBinAddr: 0x12440, symSize: 0x20 }
+  - { offsetInCU: 0x369, offset: 0x8AF56, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_yyScMYccfU_TA', symObjAddr: 0x910, symBinAddr: 0x12480, symSize: 0x20 }
+  - { offsetInCU: 0x4FE, offset: 0x8B0EB, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF4SyncySbs5Int64V_So7UIImageCtFZ', symObjAddr: 0x120, symBinAddr: 0x11D00, symSize: 0x10 }
+  - { offsetInCU: 0x58B, offset: 0x8B178, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZ', symObjAddr: 0x170, symBinAddr: 0x11D50, symSize: 0x10 }
+  - { offsetInCU: 0x59F, offset: 0x8B18C, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetC013loadImageFromF0yys5Int64V_So7UIImageCySbctFZyyYbcfU_', symObjAddr: 0x180, symBinAddr: 0x11D60, symSize: 0x240 }
+  - { offsetInCU: 0x678, offset: 0x8B265, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCACycfC', symObjAddr: 0x440, symBinAddr: 0x12020, symSize: 0x20 }
+  - { offsetInCU: 0x68C, offset: 0x8B279, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCACycfc', symObjAddr: 0x460, symBinAddr: 0x12040, symSize: 0x30 }
+  - { offsetInCU: 0x6C2, offset: 0x8B2AF, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative13NSCImageAssetCfD', symObjAddr: 0x4C0, symBinAddr: 0x120A0, symSize: 0x30 }
+  - { offsetInCU: 0x27, offset: 0x8B355, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfC', symObjAddr: 0x0, symBinAddr: 0x124F0, symSize: 0x20 }
+  - { offsetInCU: 0x77, offset: 0x8B3A5, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfcTo', symObjAddr: 0x70, symBinAddr: 0x12560, symSize: 0x30 }
+  - { offsetInCU: 0xCB, offset: 0x8B3F9, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCMa', symObjAddr: 0x50, symBinAddr: 0x12540, symSize: 0x20 }
+  - { offsetInCU: 0x216, offset: 0x8B544, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfC', symObjAddr: 0x0, symBinAddr: 0x124F0, symSize: 0x20 }
+  - { offsetInCU: 0x22A, offset: 0x8B558, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCACycfc', symObjAddr: 0x20, symBinAddr: 0x12510, symSize: 0x30 }
+  - { offsetInCU: 0x266, offset: 0x8B594, size: 0x8, addend: 0x0, symName: '_$s12CanvasNative25NSCCanvasRenderingContextCfD', symObjAddr: 0xA0, symBinAddr: 0x12590, symSize: 0x2B }
+  - { offsetInCU: 0x26, offset: 0x8B5DD, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_frombytes_vartime, symObjAddr: 0x0, symBinAddr: 0x3C38E0, symSize: 0x3990 }
+  - { offsetInCU: 0x40, offset: 0x8B5F7, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_k25519Precomp, symObjAddr: 0xEEC0, symBinAddr: 0xB5CAE0, symSize: 0x0 }
+  - { offsetInCU: 0x92, offset: 0x8B649, size: 0x8, addend: 0x0, symName: _d, symObjAddr: 0x14EC0, symBinAddr: 0xB62AE0, symSize: 0x0 }
+  - { offsetInCU: 0xF6, offset: 0x8B6AD, size: 0x8, addend: 0x0, symName: _sqrtm1, symObjAddr: 0x14EE8, symBinAddr: 0xB62B08, symSize: 0x0 }
+  - { offsetInCU: 0x10C, offset: 0x8B6C3, size: 0x8, addend: 0x0, symName: _d2, symObjAddr: 0x152F0, symBinAddr: 0xB62F10, symSize: 0x0 }
+  - { offsetInCU: 0x123, offset: 0x8B6DA, size: 0x8, addend: 0x0, symName: _Bi, symObjAddr: 0x14F30, symBinAddr: 0xB62B50, symSize: 0x0 }
+  - { offsetInCU: 0xE22, offset: 0x8C3D9, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_frombytes_vartime, symObjAddr: 0x0, symBinAddr: 0x3C38E0, symSize: 0x3990 }
+  - { offsetInCU: 0x4DAE, offset: 0x90365, size: 0x8, addend: 0x0, symName: _fe_mul_impl, symObjAddr: 0xE6E0, symBinAddr: 0x3D1FC0, symSize: 0x3E0 }
+  - { offsetInCU: 0x4FF1, offset: 0x905A8, size: 0x8, addend: 0x0, symName: _fe_tobytes, symObjAddr: 0x7C20, symBinAddr: 0x3CB500, symSize: 0x270 }
+  - { offsetInCU: 0x582C, offset: 0x90DE3, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_scalarmult_base, symObjAddr: 0x3990, symBinAddr: 0x3C7270, symSize: 0xA10 }
+  - { offsetInCU: 0x684B, offset: 0x91E02, size: 0x8, addend: 0x0, symName: _table_select, symObjAddr: 0x43A0, symBinAddr: 0x3C7C80, symSize: 0xA10 }
+  - { offsetInCU: 0x6EE9, offset: 0x924A0, size: 0x8, addend: 0x0, symName: _ge_madd, symObjAddr: 0x4DB0, symBinAddr: 0x3C8690, symSize: 0x2B0 }
+  - { offsetInCU: 0x74BC, offset: 0x92A73, size: 0x8, addend: 0x0, symName: _ge_p2_dbl, symObjAddr: 0x5060, symBinAddr: 0x3C8940, symSize: 0xCD0 }
+  - { offsetInCU: 0x83FE, offset: 0x939B5, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_sc_reduce, symObjAddr: 0x5D30, symBinAddr: 0x3C9610, symSize: 0xB40 }
+  - { offsetInCU: 0x8F67, offset: 0x9451E, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_scalar_mult_generic_masked, symObjAddr: 0x6870, symBinAddr: 0x3CA150, symSize: 0x13B0 }
+  - { offsetInCU: 0xA567, offset: 0x95B1E, size: 0x8, addend: 0x0, symName: _fe_loose_invert, symObjAddr: 0x7FF0, symBinAddr: 0x3CB8D0, symSize: 0x2A30 }
+  - { offsetInCU: 0xDC6D, offset: 0x99224, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_public_from_private_generic_masked, symObjAddr: 0x7E90, symBinAddr: 0x3CB770, symSize: 0x160 }
+  - { offsetInCU: 0xDEE7, offset: 0x9949E, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_invert, symObjAddr: 0xAA20, symBinAddr: 0x3CE300, symSize: 0x30 }
+  - { offsetInCU: 0xDFDC, offset: 0x99593, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_isnegative, symObjAddr: 0xAA50, symBinAddr: 0x3CE330, symSize: 0x50 }
+  - { offsetInCU: 0xE051, offset: 0x99608, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_mul_ttt, symObjAddr: 0xAAA0, symBinAddr: 0x3CE380, symSize: 0x10 }
+  - { offsetInCU: 0xE0EC, offset: 0x996A3, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_neg, symObjAddr: 0xAAB0, symBinAddr: 0x3CE390, symSize: 0xB0 }
+  - { offsetInCU: 0xE217, offset: 0x997CE, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_fe_tobytes, symObjAddr: 0xAB60, symBinAddr: 0x3CE440, symSize: 0x10 }
+  - { offsetInCU: 0xE4E9, offset: 0x99AA0, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_double_scalarmult_vartime, symObjAddr: 0xAB70, symBinAddr: 0x3CE450, symSize: 0x21A0 }
+  - { offsetInCU: 0x1118F, offset: 0x9C746, size: 0x8, addend: 0x0, symName: _x25519_ge_add, symObjAddr: 0xEAC0, symBinAddr: 0x3D23A0, symSize: 0x2D1 }
+  - { offsetInCU: 0x117CF, offset: 0x9CD86, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_sc_mask, symObjAddr: 0xCD10, symBinAddr: 0x3D05F0, symSize: 0x20 }
+  - { offsetInCU: 0x11C6C, offset: 0x9D223, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_sc_muladd, symObjAddr: 0xCD30, symBinAddr: 0x3D0610, symSize: 0x19B0 }
+  - { offsetInCU: 0x26, offset: 0x9E2D3, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_nohw_set_encrypt_key, symObjAddr: 0x0, symBinAddr: 0x3D2680, symSize: 0x800 }
+  - { offsetInCU: 0x41, offset: 0x9E2EE, size: 0x8, addend: 0x0, symName: _aes_nohw_rcon, symObjAddr: 0x1B10, symBinAddr: 0xB62FF0, symSize: 0x0 }
+  - { offsetInCU: 0x484, offset: 0x9E731, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_nohw_set_encrypt_key, symObjAddr: 0x0, symBinAddr: 0x3D2680, symSize: 0x800 }
+  - { offsetInCU: 0x1B2B, offset: 0x9FDD8, size: 0x8, addend: 0x0, symName: _aes_nohw_sub_bytes, symObjAddr: 0x15F0, symBinAddr: 0x3D3C70, symSize: 0x300 }
+  - { offsetInCU: 0x32EE, offset: 0xA159B, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_nohw_encrypt, symObjAddr: 0x800, symBinAddr: 0x3D2E80, symSize: 0x80 }
+  - { offsetInCU: 0x33DC, offset: 0xA1689, size: 0x8, addend: 0x0, symName: _aes_nohw_expand_round_keys, symObjAddr: 0x880, symBinAddr: 0x3D2F00, symSize: 0x1A0 }
+  - { offsetInCU: 0x386D, offset: 0xA1B1A, size: 0x8, addend: 0x0, symName: _aes_nohw_to_batch, symObjAddr: 0xA20, symBinAddr: 0x3D30A0, symSize: 0x420 }
+  - { offsetInCU: 0x3D7D, offset: 0xA202A, size: 0x8, addend: 0x0, symName: _aes_nohw_encrypt_batch, symObjAddr: 0xE40, symBinAddr: 0x3D34C0, symSize: 0x380 }
+  - { offsetInCU: 0x424C, offset: 0xA24F9, size: 0x8, addend: 0x0, symName: _aes_nohw_from_batch, symObjAddr: 0x11C0, symBinAddr: 0x3D3840, symSize: 0x250 }
+  - { offsetInCU: 0x498D, offset: 0xA2C3A, size: 0x8, addend: 0x0, symName: _aes_nohw_shift_rows, symObjAddr: 0x18F0, symBinAddr: 0x3D3F70, symSize: 0x149 }
+  - { offsetInCU: 0x4BF9, offset: 0xA2EA6, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_nohw_ctr32_encrypt_blocks, symObjAddr: 0x1410, symBinAddr: 0x3D3A90, symSize: 0x1E0 }
+  - { offsetInCU: 0x26, offset: 0xA32C7, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_from_montgomery_in_place, symObjAddr: 0x0, symBinAddr: 0x3D40C0, symSize: 0x2DC }
+  - { offsetInCU: 0x1D2, offset: 0xA3473, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_from_montgomery_in_place, symObjAddr: 0x0, symBinAddr: 0x3D40C0, symSize: 0x2DC }
+  - { offsetInCU: 0x26, offset: 0xA36CC, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_neg_inv_mod_r_u64, symObjAddr: 0x0, symBinAddr: 0x3D43A0, symSize: 0x87 }
+  - { offsetInCU: 0x34, offset: 0xA36DA, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_neg_inv_mod_r_u64, symObjAddr: 0x0, symBinAddr: 0x3D43A0, symSize: 0x87 }
+  - { offsetInCU: 0x26, offset: 0xA37EA, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_little_endian_bytes_from_scalar, symObjAddr: 0x0, symBinAddr: 0x3D4430, symSize: 0x46 }
+  - { offsetInCU: 0x34, offset: 0xA37F8, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_little_endian_bytes_from_scalar, symObjAddr: 0x0, symBinAddr: 0x3D4430, symSize: 0x46 }
+  - { offsetInCU: 0x86, offset: 0xA395B, size: 0x8, addend: 0x0, symName: _Q_N0, symObjAddr: 0x15F0, symBinAddr: 0xB63070, symSize: 0x0 }
+  - { offsetInCU: 0xB8, offset: 0xA398D, size: 0x8, addend: 0x0, symName: _Q, symObjAddr: 0x1580, symBinAddr: 0xB63000, symSize: 0x0 }
+  - { offsetInCU: 0xDA, offset: 0xA39AF, size: 0x8, addend: 0x0, symName: _N, symObjAddr: 0x15B0, symBinAddr: 0xB63030, symSize: 0x0 }
+  - { offsetInCU: 0xF0, offset: 0xA39C5, size: 0x8, addend: 0x0, symName: _N_N0, symObjAddr: 0x15E0, symBinAddr: 0xB63060, symSize: 0x0 }
+  - { offsetInCU: 0x3B7, offset: 0xA3C8C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_elem_mul_mont, symObjAddr: 0x150, symBinAddr: 0x3D4480, symSize: 0x20 }
+  - { offsetInCU: 0x594, offset: 0xA3E69, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_scalar_mul_mont, symObjAddr: 0x250, symBinAddr: 0x3D44A0, symSize: 0x20 }
+  - { offsetInCU: 0x63F, offset: 0xA3F14, size: 0x8, addend: 0x0, symName: _nistz384_point_double, symObjAddr: 0x340, symBinAddr: 0x3D44C0, symSize: 0x3A0 }
+  - { offsetInCU: 0x11A7, offset: 0xA4A7C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_point_add, symObjAddr: 0x6E0, symBinAddr: 0x3D4860, symSize: 0x140 }
+  - { offsetInCU: 0x14A2, offset: 0xA4D77, size: 0x8, addend: 0x0, symName: _nistz384_point_add, symObjAddr: 0x820, symBinAddr: 0x3D49A0, symSize: 0x6B0 }
+  - { offsetInCU: 0x26DA, offset: 0xA5FAF, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p384_point_mul, symObjAddr: 0xED0, symBinAddr: 0x3D5050, symSize: 0x380 }
+  - { offsetInCU: 0x2D37, offset: 0xA660C, size: 0x8, addend: 0x0, symName: _p384_point_select_w5, symObjAddr: 0x1250, symBinAddr: 0x3D53D0, symSize: 0x170 }
+  - { offsetInCU: 0x2F2F, offset: 0xA6804, size: 0x8, addend: 0x0, symName: _add_precomputed_w5, symObjAddr: 0x13C0, symBinAddr: 0x3D5540, symSize: 0x1BF }
+  - { offsetInCU: 0x26, offset: 0xA6B4F, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_zero, symObjAddr: 0x0, symBinAddr: 0x3D5700, symSize: 0x50 }
+  - { offsetInCU: 0xFA, offset: 0xA6C23, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_zero, symObjAddr: 0x0, symBinAddr: 0x3D5700, symSize: 0x50 }
+  - { offsetInCU: 0x18D, offset: 0xA6CB6, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_equal, symObjAddr: 0x50, symBinAddr: 0x3D5750, symSize: 0x60 }
+  - { offsetInCU: 0x2F1, offset: 0xA6E1A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_equal_limb, symObjAddr: 0xB0, symBinAddr: 0x3D57B0, symSize: 0x90 }
+  - { offsetInCU: 0x4C6, offset: 0xA6FEF, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_are_even, symObjAddr: 0x140, symBinAddr: 0x3D5840, symSize: 0x20 }
+  - { offsetInCU: 0x5E3, offset: 0xA710C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_less_than, symObjAddr: 0x160, symBinAddr: 0x3D5860, symSize: 0xB0 }
+  - { offsetInCU: 0x696, offset: 0xA71BF, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_less_than_limb, symObjAddr: 0x210, symBinAddr: 0x3D5910, symSize: 0x70 }
+  - { offsetInCU: 0x861, offset: 0xA738A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_reduce_once, symObjAddr: 0x280, symBinAddr: 0x3D5980, symSize: 0x170 }
+  - { offsetInCU: 0xB67, offset: 0xA7690, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_add_mod, symObjAddr: 0x3F0, symBinAddr: 0x3D5AF0, symSize: 0x270 }
+  - { offsetInCU: 0xE6A, offset: 0xA7993, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_sub_mod, symObjAddr: 0x660, symBinAddr: 0x3D5D60, symSize: 0x1A0 }
+  - { offsetInCU: 0x105D, offset: 0xA7B86, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_shl_mod, symObjAddr: 0x800, symBinAddr: 0x3D5F00, symSize: 0x280 }
+  - { offsetInCU: 0x128C, offset: 0xA7DB5, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_window5_split_window, symObjAddr: 0xC20, symBinAddr: 0x3D6180, symSize: 0x20 }
+  - { offsetInCU: 0x12F3, offset: 0xA7E1C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMBS_window5_unsplit_window, symObjAddr: 0xC40, symBinAddr: 0x3D61A0, symSize: 0x20 }
+  - { offsetInCU: 0x132A, offset: 0xA7E53, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_LIMB_shr, symObjAddr: 0xC60, symBinAddr: 0x3D61C0, symSize: 0x10 }
+  - { offsetInCU: 0x13AC, offset: 0xA7ED5, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_limbs_mul_add_limb, symObjAddr: 0xC70, symBinAddr: 0x3D61D0, symSize: 0x4A }
+  - { offsetInCU: 0x26, offset: 0xA8061, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_CRYPTO_memcmp, symObjAddr: 0x0, symBinAddr: 0x3D6220, symSize: 0x129 }
+  - { offsetInCU: 0x34, offset: 0xA806F, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_CRYPTO_memcmp, symObjAddr: 0x0, symBinAddr: 0x3D6220, symSize: 0x129 }
+  - { offsetInCU: 0x34, offset: 0xA8171, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_OPENSSL_ia32cap_P, symObjAddr: 0x3F0, symBinAddr: 0x136B210, symSize: 0x0 }
+  - { offsetInCU: 0x26, offset: 0xA81C6, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_OPENSSL_cpuid_setup, symObjAddr: 0x0, symBinAddr: 0x3D6350, symSize: 0xF8 }
+  - { offsetInCU: 0xD5, offset: 0xA8275, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_OPENSSL_cpuid_setup, symObjAddr: 0x0, symBinAddr: 0x3D6350, symSize: 0xF8 }
+  - { offsetInCU: 0x26, offset: 0xA83CA, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_scalar_mult_adx, symObjAddr: 0x0, symBinAddr: 0x3D6450, symSize: 0x1210 }
+  - { offsetInCU: 0x92E, offset: 0xA8CD2, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_scalar_mult_adx, symObjAddr: 0x0, symBinAddr: 0x3D6450, symSize: 0x1210 }
+  - { offsetInCU: 0x5347, offset: 0xAD6EB, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_x25519_ge_scalarmult_base_adx, symObjAddr: 0x1210, symBinAddr: 0x3D7660, symSize: 0x1E50 }
+  - { offsetInCU: 0x9B2F, offset: 0xB1ED3, size: 0x8, addend: 0x0, symName: _inline_x25519_ge_dbl_4, symObjAddr: 0x3060, symBinAddr: 0x3D94B0, symSize: 0x361 }
+  - { offsetInCU: 0x26, offset: 0xB32C0, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_CRYPTO_poly1305_init, symObjAddr: 0x0, symBinAddr: 0x3D9820, symSize: 0xD0 }
+  - { offsetInCU: 0x303, offset: 0xB359D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_CRYPTO_poly1305_init, symObjAddr: 0x0, symBinAddr: 0x3D9820, symSize: 0xD0 }
+  - { offsetInCU: 0x5A4, offset: 0xB383E, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_CRYPTO_poly1305_update, symObjAddr: 0xD0, symBinAddr: 0x3D98F0, symSize: 0x1C0 }
+  - { offsetInCU: 0x764, offset: 0xB39FE, size: 0x8, addend: 0x0, symName: _poly1305_blocks, symObjAddr: 0x5F0, symBinAddr: 0x3D9E10, symSize: 0x780 }
+  - { offsetInCU: 0x903, offset: 0xB3B9D, size: 0x8, addend: 0x0, symName: _poly1305_first_block, symObjAddr: 0x290, symBinAddr: 0x3D9AB0, symSize: 0x360 }
+  - { offsetInCU: 0xEFC, offset: 0xB4196, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_CRYPTO_poly1305_finish, symObjAddr: 0xD70, symBinAddr: 0x3DA590, symSize: 0xAA2 }
+  - { offsetInCU: 0x10, offset: 0xB491F, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_fiat_curve25519_adx_mul, symObjAddr: 0x0, symBinAddr: 0x3DB032, symSize: 0x2AF }
+  - { offsetInCU: 0x51, offset: 0xB4960, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_fiat_curve25519_adx_mul, symObjAddr: 0x0, symBinAddr: 0x3DB032, symSize: 0x2AF }
+  - { offsetInCU: 0x10, offset: 0xB4955, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_fiat_curve25519_adx_square, symObjAddr: 0x0, symBinAddr: 0x3DB2E1, symSize: 0x1F4 }
+  - { offsetInCU: 0x54, offset: 0xB4999, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_fiat_curve25519_adx_square, symObjAddr: 0x0, symBinAddr: 0x3DB2E1, symSize: 0x1F4 }
+  - { offsetInCU: 0x26, offset: 0xB49A1, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul, symObjAddr: 0x0, symBinAddr: 0x3DB4E0, symSize: 0x490 }
+  - { offsetInCU: 0x76, offset: 0xB49F1, size: 0x8, addend: 0x0, symName: _ecp_nistz256_precomputed, symObjAddr: 0x1000, symBinAddr: 0xB64000, symSize: 0x0 }
+  - { offsetInCU: 0xFA, offset: 0xB4A75, size: 0x8, addend: 0x0, symName: _ONE, symObjAddr: 0x26000, symBinAddr: 0xB89000, symSize: 0x0 }
+  - { offsetInCU: 0x35B, offset: 0xB4CD6, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul, symObjAddr: 0x0, symBinAddr: 0x3DB4E0, symSize: 0x490 }
+  - { offsetInCU: 0xC5A, offset: 0xB55D5, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul_base, symObjAddr: 0x490, symBinAddr: 0x3DB970, symSize: 0x300 }
+  - { offsetInCU: 0x1135, offset: 0xB5AB0, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_mul_base_vartime, symObjAddr: 0x790, symBinAddr: 0x3DBC70, symSize: 0x25D }
+  - { offsetInCU: 0x10, offset: 0xB5E75, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ChaCha20_ctr32, symObjAddr: 0x0, symBinAddr: 0x3DBF00, symSize: 0x3A0 }
+  - { offsetInCU: 0x48, offset: 0xB5EAD, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ChaCha20_ctr32, symObjAddr: 0x0, symBinAddr: 0x3DBF00, symSize: 0x3A0 }
+  - { offsetInCU: 0x4D, offset: 0xB5EB2, size: 0x8, addend: 0x0, symName: ChaCha20_ssse3, symObjAddr: 0x3A0, symBinAddr: 0x3DC2A0, symSize: 0x220 }
+  - { offsetInCU: 0x60, offset: 0xB5EC5, size: 0x8, addend: 0x0, symName: ChaCha20_4x, symObjAddr: 0x5C0, symBinAddr: 0x3DC4C0, symSize: 0xA20 }
+  - { offsetInCU: 0x76, offset: 0xB5EDB, size: 0x8, addend: 0x0, symName: ChaCha20_8x, symObjAddr: 0xFE0, symBinAddr: 0x3DCEE0, symSize: 0xB4C }
+  - { offsetInCU: 0x10, offset: 0xB5EED, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_encrypt, symObjAddr: 0x0, symBinAddr: 0x3DDA40, symSize: 0x40 }
+  - { offsetInCU: 0x48, offset: 0xB5F25, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_encrypt, symObjAddr: 0x0, symBinAddr: 0x3DDA40, symSize: 0x40 }
+  - { offsetInCU: 0x4D, offset: 0xB5F2A, size: 0x8, addend: 0x0, symName: _aesni_encrypt2, symObjAddr: 0x40, symBinAddr: 0x3DDA80, symSize: 0x60 }
+  - { offsetInCU: 0x63, offset: 0xB5F40, size: 0x8, addend: 0x0, symName: _aesni_encrypt3, symObjAddr: 0xA0, symBinAddr: 0x3DDAE0, symSize: 0x70 }
+  - { offsetInCU: 0x79, offset: 0xB5F56, size: 0x8, addend: 0x0, symName: _aesni_encrypt4, symObjAddr: 0x110, symBinAddr: 0x3DDB50, symSize: 0x90 }
+  - { offsetInCU: 0x8F, offset: 0xB5F6C, size: 0x8, addend: 0x0, symName: _aesni_encrypt6, symObjAddr: 0x1A0, symBinAddr: 0x3DDBE0, symSize: 0xE0 }
+  - { offsetInCU: 0xA5, offset: 0xB5F82, size: 0x8, addend: 0x0, symName: _aesni_encrypt8, symObjAddr: 0x280, symBinAddr: 0x3DDCC0, symSize: 0x110 }
+  - { offsetInCU: 0xD9, offset: 0xB5FB6, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aes_hw_ctr32_encrypt_blocks, symObjAddr: 0x390, symBinAddr: 0x3DDDD0, symSize: 0x940 }
+  - { offsetInCU: 0xEA, offset: 0xB5FC7, size: 0x8, addend: 0x0, symName: __aesni_set_encrypt_key, symObjAddr: 0xCD0, symBinAddr: 0x3DE710, symSize: 0x44D }
+  - { offsetInCU: 0x10, offset: 0xB5FBD, size: 0x8, addend: 0x0, symName: _vpaes_encrypt_core, symObjAddr: 0x0, symBinAddr: 0x3DEB60, symSize: 0x160 }
+  - { offsetInCU: 0x3B, offset: 0xB5FE8, size: 0x8, addend: 0x0, symName: _vpaes_encrypt_core, symObjAddr: 0x0, symBinAddr: 0x3DEB60, symSize: 0x160 }
+  - { offsetInCU: 0x54, offset: 0xB6001, size: 0x8, addend: 0x0, symName: _vpaes_encrypt_core_2x, symObjAddr: 0x160, symBinAddr: 0x3DECC0, symSize: 0x290 }
+  - { offsetInCU: 0x68, offset: 0xB6015, size: 0x8, addend: 0x0, symName: _vpaes_schedule_core, symObjAddr: 0x3F0, symBinAddr: 0x3DEF50, symSize: 0xF0 }
+  - { offsetInCU: 0x7F, offset: 0xB602C, size: 0x8, addend: 0x0, symName: _vpaes_schedule_round, symObjAddr: 0x4E0, symBinAddr: 0x3DF040, symSize: 0x21 }
+  - { offsetInCU: 0x99, offset: 0xB6046, size: 0x8, addend: 0x0, symName: _vpaes_schedule_low_round, symObjAddr: 0x501, symBinAddr: 0x3DF061, symSize: 0x9F }
+  - { offsetInCU: 0xAF, offset: 0xB605C, size: 0x8, addend: 0x0, symName: _vpaes_schedule_transform, symObjAddr: 0x5A0, symBinAddr: 0x3DF100, symSize: 0x30 }
+  - { offsetInCU: 0xC2, offset: 0xB606F, size: 0x8, addend: 0x0, symName: _vpaes_schedule_mangle, symObjAddr: 0x5D0, symBinAddr: 0x3DF130, symSize: 0x50 }
+  - { offsetInCU: 0xE9, offset: 0xB6096, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_vpaes_set_encrypt_key, symObjAddr: 0x620, symBinAddr: 0x3DF180, symSize: 0x30 }
+  - { offsetInCU: 0xF7, offset: 0xB60A4, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_vpaes_encrypt, symObjAddr: 0x650, symBinAddr: 0x3DF1B0, symSize: 0x20 }
+  - { offsetInCU: 0x11A, offset: 0xB60C7, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_vpaes_ctr32_encrypt_blocks, symObjAddr: 0x670, symBinAddr: 0x3DF1D0, symSize: 0xD0 }
+  - { offsetInCU: 0x112, offset: 0xB60BF, size: 0x8, addend: 0x0, symName: _vpaes_preheat, symObjAddr: 0x740, symBinAddr: 0x3DF2A0, symSize: 0x31 }
+  - { offsetInCU: 0x10, offset: 0xB60CF, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_mul_mont, symObjAddr: 0x0, symBinAddr: 0x3DF2E0, symSize: 0x2A0 }
+  - { offsetInCU: 0x45, offset: 0xB6104, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_mul_mont, symObjAddr: 0x0, symBinAddr: 0x3DF2E0, symSize: 0x2A0 }
+  - { offsetInCU: 0x4C, offset: 0xB610B, size: 0x8, addend: 0x0, symName: bn_mul4x_mont, symObjAddr: 0x2A0, symBinAddr: 0x3DF580, symSize: 0x560 }
+  - { offsetInCU: 0x62, offset: 0xB6121, size: 0x8, addend: 0x0, symName: bn_sqr8x_mont, symObjAddr: 0x800, symBinAddr: 0x3DFAE0, symSize: 0x220 }
+  - { offsetInCU: 0x79, offset: 0xB6138, size: 0x8, addend: 0x0, symName: bn_mulx4x_mont, symObjAddr: 0xA20, symBinAddr: 0x3DFD00, symSize: 0x570 }
+  - { offsetInCU: 0x10, offset: 0xB6147, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_mul_mont_gather5, symObjAddr: 0x0, symBinAddr: 0x3E0280, symSize: 0x660 }
+  - { offsetInCU: 0x4D, offset: 0xB6184, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_mul_mont_gather5, symObjAddr: 0x0, symBinAddr: 0x3E0280, symSize: 0x660 }
+  - { offsetInCU: 0x54, offset: 0xB618B, size: 0x8, addend: 0x0, symName: bn_mul4x_mont_gather5, symObjAddr: 0x660, symBinAddr: 0x3E08E0, symSize: 0x100 }
+  - { offsetInCU: 0x63, offset: 0xB619A, size: 0x8, addend: 0x0, symName: mul4x_internal, symObjAddr: 0x760, symBinAddr: 0x3E09E0, symSize: 0x7E0 }
+  - { offsetInCU: 0x85, offset: 0xB61BC, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_power5, symObjAddr: 0xF40, symBinAddr: 0x3E11C0, symSize: 0x180 }
+  - { offsetInCU: 0xA3, offset: 0xB61DA, size: 0x8, addend: 0x0, symName: __bn_sqr8x_internal, symObjAddr: 0x10C0, symBinAddr: 0x3E1340, symSize: 0x579 }
+  - { offsetInCU: 0xAA, offset: 0xB61E1, size: 0x8, addend: 0x0, symName: __bn_sqr8x_reduction, symObjAddr: 0x1639, symBinAddr: 0x3E18B9, symSize: 0x347 }
+  - { offsetInCU: 0xC0, offset: 0xB61F7, size: 0x8, addend: 0x0, symName: __bn_post4x_internal, symObjAddr: 0x1980, symBinAddr: 0x3E1C00, symSize: 0xA0 }
+  - { offsetInCU: 0xD9, offset: 0xB6210, size: 0x8, addend: 0x0, symName: bn_mulx4x_mont_gather5, symObjAddr: 0x1A20, symBinAddr: 0x3E1CA0, symSize: 0xE0 }
+  - { offsetInCU: 0xE8, offset: 0xB621F, size: 0x8, addend: 0x0, symName: mulx4x_internal, symObjAddr: 0x1B00, symBinAddr: 0x3E1D80, symSize: 0x7E0 }
+  - { offsetInCU: 0xF9, offset: 0xB6230, size: 0x8, addend: 0x0, symName: bn_powerx5, symObjAddr: 0x22E0, symBinAddr: 0x3E2560, symSize: 0x160 }
+  - { offsetInCU: 0x128, offset: 0xB625F, size: 0x8, addend: 0x0, symName: __bn_sqrx8x_internal, symObjAddr: 0x2440, symBinAddr: 0x3E26C0, symSize: 0x637 }
+  - { offsetInCU: 0x12F, offset: 0xB6266, size: 0x8, addend: 0x0, symName: __bn_sqrx8x_reduction, symObjAddr: 0x2A77, symBinAddr: 0x3E2CF7, symSize: 0x329 }
+  - { offsetInCU: 0x145, offset: 0xB627C, size: 0x8, addend: 0x0, symName: __bn_postx4x_internal, symObjAddr: 0x2DA0, symBinAddr: 0x3E3020, symSize: 0x90 }
+  - { offsetInCU: 0x163, offset: 0xB629A, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_scatter5, symObjAddr: 0x2E30, symBinAddr: 0x3E30B0, symSize: 0x30 }
+  - { offsetInCU: 0x178, offset: 0xB62AF, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_bn_gather5, symObjAddr: 0x2E60, symBinAddr: 0x3E30E0, symSize: 0x27F }
+  - { offsetInCU: 0x10, offset: 0xB62B1, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ecp_nistz256_neg, symObjAddr: 0x0, symBinAddr: 0x3E3360, symSize: 0x80 }
+  - { offsetInCU: 0x4A, offset: 0xB62EB, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ecp_nistz256_neg, symObjAddr: 0x0, symBinAddr: 0x3E3360, symSize: 0x80 }
+  - { offsetInCU: 0x64, offset: 0xB6305, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_scalar_mul_mont, symObjAddr: 0x80, symBinAddr: 0x3E33E0, symSize: 0x360 }
+  - { offsetInCU: 0x7E, offset: 0xB631F, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_scalar_sqr_rep_mont, symObjAddr: 0x3E0, symBinAddr: 0x3E3740, symSize: 0x300 }
+  - { offsetInCU: 0x85, offset: 0xB6326, size: 0x8, addend: 0x0, symName: ecp_nistz256_ord_mul_montx, symObjAddr: 0x6E0, symBinAddr: 0x3E3A40, symSize: 0x3C0 }
+  - { offsetInCU: 0x9B, offset: 0xB633C, size: 0x8, addend: 0x0, symName: ecp_nistz256_ord_sqr_montx, symObjAddr: 0xAA0, symBinAddr: 0x3E3E00, symSize: 0x320 }
+  - { offsetInCU: 0xB5, offset: 0xB6356, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_mul_mont, symObjAddr: 0xDC0, symBinAddr: 0x3E4120, symSize: 0xA0 }
+  - { offsetInCU: 0xC4, offset: 0xB6365, size: 0x8, addend: 0x0, symName: __ecp_nistz256_mul_montq, symObjAddr: 0xE60, symBinAddr: 0x3E41C0, symSize: 0x240 }
+  - { offsetInCU: 0xE1, offset: 0xB6382, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_sqr_mont, symObjAddr: 0x10A0, symBinAddr: 0x3E4400, symSize: 0x80 }
+  - { offsetInCU: 0xF0, offset: 0xB6391, size: 0x8, addend: 0x0, symName: __ecp_nistz256_sqr_montq, symObjAddr: 0x1120, symBinAddr: 0x3E4480, symSize: 0x1A0 }
+  - { offsetInCU: 0x106, offset: 0xB63A7, size: 0x8, addend: 0x0, symName: __ecp_nistz256_mul_montx, symObjAddr: 0x12C0, symBinAddr: 0x3E4620, symSize: 0x260 }
+  - { offsetInCU: 0x11C, offset: 0xB63BD, size: 0x8, addend: 0x0, symName: __ecp_nistz256_sqr_montx, symObjAddr: 0x1520, symBinAddr: 0x3E4880, symSize: 0x1C0 }
+  - { offsetInCU: 0x142, offset: 0xB63E3, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ecp_nistz256_select_w5, symObjAddr: 0x16E0, symBinAddr: 0x3E4A40, symSize: 0xE0 }
+  - { offsetInCU: 0x158, offset: 0xB63F9, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_ecp_nistz256_select_w7, symObjAddr: 0x17C0, symBinAddr: 0x3E4B20, symSize: 0xC0 }
+  - { offsetInCU: 0x162, offset: 0xB6403, size: 0x8, addend: 0x0, symName: ecp_nistz256_avx2_select_w5, symObjAddr: 0x1880, symBinAddr: 0x3E4BE0, symSize: 0xC0 }
+  - { offsetInCU: 0x178, offset: 0xB6419, size: 0x8, addend: 0x0, symName: ecp_nistz256_avx2_select_w7, symObjAddr: 0x1940, symBinAddr: 0x3E4CA0, symSize: 0xE0 }
+  - { offsetInCU: 0x188, offset: 0xB6429, size: 0x8, addend: 0x0, symName: __ecp_nistz256_add_toq, symObjAddr: 0x1A20, symBinAddr: 0x3E4D80, symSize: 0x60 }
+  - { offsetInCU: 0x1A0, offset: 0xB6441, size: 0x8, addend: 0x0, symName: __ecp_nistz256_sub_fromq, symObjAddr: 0x1A80, symBinAddr: 0x3E4DE0, symSize: 0x60 }
+  - { offsetInCU: 0x1B1, offset: 0xB6452, size: 0x8, addend: 0x0, symName: __ecp_nistz256_subq, symObjAddr: 0x1AE0, symBinAddr: 0x3E4E40, symSize: 0x40 }
+  - { offsetInCU: 0x1CC, offset: 0xB646D, size: 0x8, addend: 0x0, symName: __ecp_nistz256_mul_by_2q, symObjAddr: 0x1B20, symBinAddr: 0x3E4E80, symSize: 0x60 }
+  - { offsetInCU: 0x1ED, offset: 0xB648E, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_double, symObjAddr: 0x1B80, symBinAddr: 0x3E4EE0, symSize: 0x320 }
+  - { offsetInCU: 0x200, offset: 0xB64A1, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_add, symObjAddr: 0x1EA0, symBinAddr: 0x3E5200, symSize: 0x780 }
+  - { offsetInCU: 0x21D, offset: 0xB64BE, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_p256_point_add_affine, symObjAddr: 0x2620, symBinAddr: 0x3E5980, symSize: 0x580 }
+  - { offsetInCU: 0x222, offset: 0xB64C3, size: 0x8, addend: 0x0, symName: __ecp_nistz256_add_tox, symObjAddr: 0x2BA0, symBinAddr: 0x3E5F00, symSize: 0x60 }
+  - { offsetInCU: 0x23A, offset: 0xB64DB, size: 0x8, addend: 0x0, symName: __ecp_nistz256_sub_fromx, symObjAddr: 0x2C00, symBinAddr: 0x3E5F60, symSize: 0x60 }
+  - { offsetInCU: 0x24B, offset: 0xB64EC, size: 0x8, addend: 0x0, symName: __ecp_nistz256_subx, symObjAddr: 0x2C60, symBinAddr: 0x3E5FC0, symSize: 0x60 }
+  - { offsetInCU: 0x266, offset: 0xB6507, size: 0x8, addend: 0x0, symName: __ecp_nistz256_mul_by_2x, symObjAddr: 0x2CC0, symBinAddr: 0x3E6020, symSize: 0x60 }
+  - { offsetInCU: 0x27F, offset: 0xB6520, size: 0x8, addend: 0x0, symName: ecp_nistz256_point_doublex, symObjAddr: 0x2D20, symBinAddr: 0x3E6080, symSize: 0x320 }
+  - { offsetInCU: 0x292, offset: 0xB6533, size: 0x8, addend: 0x0, symName: ecp_nistz256_point_addx, symObjAddr: 0x3040, symBinAddr: 0x3E63A0, symSize: 0x760 }
+  - { offsetInCU: 0x2AF, offset: 0xB6550, size: 0x8, addend: 0x0, symName: ecp_nistz256_point_add_affinex, symObjAddr: 0x37A0, symBinAddr: 0x3E6B00, symSize: 0x555 }
+  - { offsetInCU: 0x10, offset: 0xB654F, size: 0x8, addend: 0x0, symName: _aesni_ctr32_ghash_6x, symObjAddr: 0x0, symBinAddr: 0x3E7060, symSize: 0x5A0 }
+  - { offsetInCU: 0x3D, offset: 0xB657C, size: 0x8, addend: 0x0, symName: _aesni_ctr32_ghash_6x, symObjAddr: 0x0, symBinAddr: 0x3E7060, symSize: 0x5A0 }
+  - { offsetInCU: 0x61, offset: 0xB65A0, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aesni_gcm_decrypt, symObjAddr: 0x5A0, symBinAddr: 0x3E7600, symSize: 0x140 }
+  - { offsetInCU: 0x63, offset: 0xB65A2, size: 0x8, addend: 0x0, symName: _aesni_ctr32_6x, symObjAddr: 0x6E0, symBinAddr: 0x3E7740, symSize: 0x180 }
+  - { offsetInCU: 0x8D, offset: 0xB65CC, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_aesni_gcm_encrypt, symObjAddr: 0x860, symBinAddr: 0x3E78C0, symSize: 0x423 }
+  - { offsetInCU: 0x10, offset: 0xB65C7, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_init_clmul, symObjAddr: 0x0, symBinAddr: 0x3E7D00, symSize: 0x260 }
+  - { offsetInCU: 0x48, offset: 0xB65FF, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_init_clmul, symObjAddr: 0x0, symBinAddr: 0x3E7D00, symSize: 0x260 }
+  - { offsetInCU: 0x5F, offset: 0xB6616, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_gmult_clmul, symObjAddr: 0x260, symBinAddr: 0x3E7F60, symSize: 0xC0 }
+  - { offsetInCU: 0x75, offset: 0xB662C, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_ghash_clmul, symObjAddr: 0x320, symBinAddr: 0x3E8020, symSize: 0x660 }
+  - { offsetInCU: 0x88, offset: 0xB663F, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_init_avx, symObjAddr: 0x980, symBinAddr: 0x3E8680, symSize: 0x1A0 }
+  - { offsetInCU: 0x9F, offset: 0xB6656, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_gcm_ghash_avx, symObjAddr: 0xB20, symBinAddr: 0x3E8820, symSize: 0x697 }
+  - { offsetInCU: 0x10, offset: 0xB6655, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha512_block_data_order, symObjAddr: 0x0, symBinAddr: 0x3E8EC0, symSize: 0x1240 }
+  - { offsetInCU: 0x51, offset: 0xB6696, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha512_block_data_order, symObjAddr: 0x0, symBinAddr: 0x3E8EC0, symSize: 0x1240 }
+  - { offsetInCU: 0x5A, offset: 0xB669F, size: 0x8, addend: 0x0, symName: sha512_block_data_order_avx, symObjAddr: 0x1240, symBinAddr: 0x3EA100, symSize: 0x1176 }
+  - { offsetInCU: 0x10, offset: 0xB66A1, size: 0x8, addend: 0x0, symName: poly_hash_ad_internal, symObjAddr: 0x0, symBinAddr: 0x3EB280, symSize: 0x200 }
+  - { offsetInCU: 0x44, offset: 0xB66D5, size: 0x8, addend: 0x0, symName: poly_hash_ad_internal, symObjAddr: 0x0, symBinAddr: 0x3EB280, symSize: 0x200 }
+  - { offsetInCU: 0x66, offset: 0xB66F7, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_chacha20_poly1305_open, symObjAddr: 0x200, symBinAddr: 0x3EB480, symSize: 0x21C0 }
+  - { offsetInCU: 0x7C, offset: 0xB670D, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_chacha20_poly1305_seal, symObjAddr: 0x23C0, symBinAddr: 0x3ED640, symSize: 0x1D2D }
+  - { offsetInCU: 0x83, offset: 0xB6714, size: 0x8, addend: 0x0, symName: process_extra_in_trailer, symObjAddr: 0x40ED, symBinAddr: 0x3EF36D, symSize: 0x553 }
+  - { offsetInCU: 0x9C, offset: 0xB672D, size: 0x8, addend: 0x0, symName: chacha20_poly1305_open_avx2, symObjAddr: 0x4640, symBinAddr: 0x3EF8C0, symSize: 0x25C0 }
+  - { offsetInCU: 0xB2, offset: 0xB6743, size: 0x8, addend: 0x0, symName: chacha20_poly1305_seal_avx2, symObjAddr: 0x6C00, symBinAddr: 0x3F1E80, symSize: 0x2F01 }
+  - { offsetInCU: 0x10, offset: 0xB6745, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha256_block_data_order, symObjAddr: 0x0, symBinAddr: 0x3F4DC0, symSize: 0x1200 }
+  - { offsetInCU: 0x51, offset: 0xB6786, size: 0x8, addend: 0x0, symName: _ring_core_0_17_8_sha256_block_data_order, symObjAddr: 0x0, symBinAddr: 0x3F4DC0, symSize: 0x1200 }
+  - { offsetInCU: 0x5D, offset: 0xB6792, size: 0x8, addend: 0x0, symName: sha256_block_data_order_shaext, symObjAddr: 0x1200, symBinAddr: 0x3F5FC0, symSize: 0x340 }
+  - { offsetInCU: 0x72, offset: 0xB67A7, size: 0x8, addend: 0x0, symName: sha256_block_data_order_ssse3, symObjAddr: 0x1540, symBinAddr: 0x3F6300, symSize: 0xEC0 }
+  - { offsetInCU: 0x86, offset: 0xB67BB, size: 0x8, addend: 0x0, symName: sha256_block_data_order_avx, symObjAddr: 0x2400, symBinAddr: 0x3F71C0, symSize: 0xEF7 }
 ...
diff --git a/tools/demo/canvas/index.ts b/tools/demo/canvas/index.ts
index 4699c1445..c7f9b444c 100644
--- a/tools/demo/canvas/index.ts
+++ b/tools/demo/canvas/index.ts
@@ -490,6 +490,24 @@ fn fragment_main(fragData: VertexOut) -> @location(0) vec4f
 }
 `;
 
+		const triangle_vert = `@vertex
+fn main(
+  @builtin(vertex_index) VertexIndex : u32
+) -> @builtin(position) vec4f {
+  var pos = array<vec2f, 3>(
+    vec2(0.0, 0.5),
+    vec2(-0.5, -0.5),
+    vec2(0.5, -0.5)
+  );
+
+  return vec4f(pos[VertexIndex], 0.0, 1.0);
+}`;
+
+		const red_frag = `@fragment
+fn main() -> @location(0) vec4f {
+  return vec4(1.0, 0.0, 0.0, 1.0);
+}`;
+
 		if (navigator.gpu) {
 			const adapter = await navigator.gpu.requestAdapter();
 			const device = await adapter.requestDevice();
@@ -497,100 +515,65 @@ fn fragment_main(fragData: VertexOut) -> @location(0) vec4f
 			const shaderModule = device.createShaderModule({
 				code: shaders,
 			});
-
-
+			
 			const context = this.canvas.getContext('webgpu') as GPUCanvasContext;
 
+			console.log((<any>context).capabilities(adapter));
+
+			const presentationFormat = navigator.gpu.getPreferredCanvasFormat();
 
 			context.configure({
 				device,
-				format: navigator.gpu.getPreferredCanvasFormat(),
-				alphaMode: global.isIOS? 'postMultiplied' : 'premultiplied' as any,
-			});
-
-			const vertexBuffer = device.createBuffer({
-				size: vertices.byteLength, // make it big enough to store vertices in
-				usage: global.GPUBufferUsage.VERTEX | global.GPUBufferUsage.COPY_DST,
-				mappedAtCreation: false,
+				format: presentationFormat,
+				alphaMode: global.isIOS ? 'postmultiplied' : ('inherit' as any),
 			});
 
-			device.queue.writeBuffer(vertexBuffer, 0, vertices, 0, vertices.length);
-
-			const vertexBuffers = [
-				{
-					attributes: [
-						{
-							shaderLocation: 0, // position
-							offset: 0,
-							format: 'float32x4',
-						},
-						{
-							shaderLocation: 1, // color
-							offset: 16,
-							format: 'float32x4',
-						},
-					],
-					arrayStride: 32,
-					stepMode: 'vertex',
-				},
-			];
-
-			const pipelineDescriptor = {
+			const pipeline = device.createRenderPipeline({
+				layout: 'auto',
 				vertex: {
-					module: shaderModule,
-					entryPoint: 'vertex_main',
-					buffers: vertexBuffers,
+					module: device.createShaderModule({
+						code: triangle_vert,
+					}),
+					entryPoint: 'main',
 				},
 				fragment: {
-					module: shaderModule,
-					entryPoint: 'fragment_main',
+					module: device.createShaderModule({
+						code: red_frag,
+					}),
 					targets: [
 						{
-							format: navigator.gpu.getPreferredCanvasFormat(),
+							format: presentationFormat,
 						},
 					],
+					entryPoint: 'main',
 				},
 				primitive: {
 					topology: 'triangle-list',
 				},
-				layout: 'auto',
-			};
+			});
 
-			// 6: Create the actual render pipeline
 
-			const renderPipeline = device.createRenderPipeline(pipelineDescriptor as any);
+			const texture = context.getCurrentTexture();
 
-			// 7: Create GPUCommandEncoder to issue commands to the GPU
-			// Note: render pass descriptor, command encoder, etc. are destroyed after use, fresh one needed for each frame.
 			const commandEncoder = device.createCommandEncoder();
+			const textureView = texture.createView();
 
-			// 8: Create GPURenderPassDescriptor to tell WebGPU which texture to draw into, then initiate render pass
-
-			const renderPassDescriptor = {
+			const passEncoder = commandEncoder.beginRenderPass({
 				colorAttachments: [
 					{
-						clearValue: clearColor,
+						view: textureView,
+						clearValue: [0, 0, 0, 1],
 						loadOp: 'clear',
 						storeOp: 'store',
-						view: context.getCurrentTexture().createView(),
 					},
 				],
-			};
-
-
-			const passEncoder = commandEncoder.beginRenderPass(renderPassDescriptor as any);
-
-			// 9: Draw the triangle
-
-			passEncoder.setPipeline(renderPipeline);
-			passEncoder.setVertexBuffer(0, vertexBuffer);
+			});
+			passEncoder.setPipeline(pipeline);
 			passEncoder.draw(3);
-
-			// End the render pass
 			passEncoder.end();
 
-			// 10: End frame by passing array of command buffers to command queue for execution
 			device.queue.submit([commandEncoder.finish()]);
+			(<any>context).presentSurface();
 		}
 	}