// Generated by `wit-bindgen` 0.57.1. DO NOT EDIT!
// Options used:
#[allow(dead_code, clippy::all)]
pub mod bex {
  pub mod plugin {

    #[allow(dead_code, async_fn_in_trait, unused_imports, clippy::all)]
    pub mod common {
      #[used]
      #[doc(hidden)]
      static __FORCE_SECTION_REF: fn() =
      super::super::super::__link_custom_section_describing_imports;
      
      use super::super::super::_rt;
      #[derive(Clone)]
      pub struct RequestContext {
        pub request_id: _rt::String,
        pub locale: Option<_rt::String>,
        pub region: Option<_rt::String>,
        pub safe_mode: bool,
        pub hints: _rt::Vec::<_rt::String>,
      }
      impl ::core::fmt::Debug for RequestContext {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          f.debug_struct("RequestContext").field("request-id", &self.request_id).field("locale", &self.locale).field("region", &self.region).field("safe-mode", &self.safe_mode).field("hints", &self.hints).finish()
        }
      }
      #[derive(Clone)]
      pub struct Attr {
        pub key: _rt::String,
        pub value: _rt::String,
      }
      impl ::core::fmt::Debug for Attr {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          f.debug_struct("Attr").field("key", &self.key).field("value", &self.value).finish()
        }
      }
      #[repr(u8)]
      #[derive(Clone, Copy, Eq, Ord, PartialEq, PartialOrd)]
      pub enum ImageLayout {
        Portrait,
        Landscape,
        Square,
        Banner,
        Circular,
        Unknown,
      }
      impl ::core::fmt::Debug for ImageLayout {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          match self {
            ImageLayout::Portrait => {
              f.debug_tuple("ImageLayout::Portrait").finish()
            }
            ImageLayout::Landscape => {
              f.debug_tuple("ImageLayout::Landscape").finish()
            }
            ImageLayout::Square => {
              f.debug_tuple("ImageLayout::Square").finish()
            }
            ImageLayout::Banner => {
              f.debug_tuple("ImageLayout::Banner").finish()
            }
            ImageLayout::Circular => {
              f.debug_tuple("ImageLayout::Circular").finish()
            }
            ImageLayout::Unknown => {
              f.debug_tuple("ImageLayout::Unknown").finish()
            }
          }
        }
      }

      impl ImageLayout{
        #[doc(hidden)]
        pub unsafe fn _lift(val: u8) -> ImageLayout{
          if !cfg!(debug_assertions) {
            return unsafe { ::core::mem::transmute(val) };
          }

          match val {
            0 => ImageLayout::Portrait,
            1 => ImageLayout::Landscape,
            2 => ImageLayout::Square,
            3 => ImageLayout::Banner,
            4 => ImageLayout::Circular,
            5 => ImageLayout::Unknown,

            _ => panic!("invalid enum discriminant"),
          }
        }
      }

      #[derive(Clone)]
      pub struct Image {
        pub url: _rt::String,
        pub layout: ImageLayout,
        pub width: Option<u32>,
        pub height: Option<u32>,
        pub blurhash: Option<_rt::String>,
      }
      impl ::core::fmt::Debug for Image {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          f.debug_struct("Image").field("url", &self.url).field("layout", &self.layout).field("width", &self.width).field("height", &self.height).field("blurhash", &self.blurhash).finish()
        }
      }
      #[derive(Clone)]
      pub struct ImageSet {
        pub low: Option<Image>,
        pub medium: Option<Image>,
        pub high: Option<Image>,
        pub backdrop: Option<Image>,
        pub logo: Option<Image>,
      }
      impl ::core::fmt::Debug for ImageSet {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          f.debug_struct("ImageSet").field("low", &self.low).field("medium", &self.medium).field("high", &self.high).field("backdrop", &self.backdrop).field("logo", &self.logo).finish()
        }
      }
      #[derive(Clone)]
      pub struct LinkedId {
        pub source: _rt::String,
        pub id: _rt::String,
      }
      impl ::core::fmt::Debug for LinkedId {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          f.debug_struct("LinkedId").field("source", &self.source).field("id", &self.id).finish()
        }
      }
      #[repr(u8)]
      #[derive(Clone, Copy, Eq, Ord, PartialEq, PartialOrd)]
      pub enum MediaKind {
        Movie,
        Series,
        Anime,
        Short,
        Special,
        Documentary,
        Music,
        Podcast,
        Book,
        Live,
        Unknown,
      }
      impl ::core::fmt::Debug for MediaKind {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          match self {
            MediaKind::Movie => {
              f.debug_tuple("MediaKind::Movie").finish()
            }
            MediaKind::Series => {
              f.debug_tuple("MediaKind::Series").finish()
            }
            MediaKind::Anime => {
              f.debug_tuple("MediaKind::Anime").finish()
            }
            MediaKind::Short => {
              f.debug_tuple("MediaKind::Short").finish()
            }
            MediaKind::Special => {
              f.debug_tuple("MediaKind::Special").finish()
            }
            MediaKind::Documentary => {
              f.debug_tuple("MediaKind::Documentary").finish()
            }
            MediaKind::Music => {
              f.debug_tuple("MediaKind::Music").finish()
            }
            MediaKind::Podcast => {
              f.debug_tuple("MediaKind::Podcast").finish()
            }
            MediaKind::Book => {
              f.debug_tuple("MediaKind::Book").finish()
            }
            MediaKind::Live => {
              f.debug_tuple("MediaKind::Live").finish()
            }
            MediaKind::Unknown => {
              f.debug_tuple("MediaKind::Unknown").finish()
            }
          }
        }
      }

      impl MediaKind{
        #[doc(hidden)]
        pub unsafe fn _lift(val: u8) -> MediaKind{
          if !cfg!(debug_assertions) {
            return unsafe { ::core::mem::transmute(val) };
          }

          match val {
            0 => MediaKind::Movie,
            1 => MediaKind::Series,
            2 => MediaKind::Anime,
            3 => MediaKind::Short,
            4 => MediaKind::Special,
            5 => MediaKind::Documentary,
            6 => MediaKind::Music,
            7 => MediaKind::Podcast,
            8 => MediaKind::Book,
            9 => MediaKind::Live,
            10 => MediaKind::Unknown,

            _ => panic!("invalid enum discriminant"),
          }
        }
      }

      #[repr(u8)]
      #[derive(Clone, Copy, Eq, Ord, PartialEq, PartialOrd)]
      pub enum Status {
        Unknown,
        Upcoming,
        Ongoing,
        Completed,
        Cancelled,
        Paused,
      }
      impl ::core::fmt::Debug for Status {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          match self {
            Status::Unknown => {
              f.debug_tuple("Status::Unknown").finish()
            }
            Status::Upcoming => {
              f.debug_tuple("Status::Upcoming").finish()
            }
            Status::Ongoing => {
              f.debug_tuple("Status::Ongoing").finish()
            }
            Status::Completed => {
              f.debug_tuple("Status::Completed").finish()
            }
            Status::Cancelled => {
              f.debug_tuple("Status::Cancelled").finish()
            }
            Status::Paused => {
              f.debug_tuple("Status::Paused").finish()
            }
          }
        }
      }

      impl Status{
        #[doc(hidden)]
        pub unsafe fn _lift(val: u8) -> Status{
          if !cfg!(debug_assertions) {
            return unsafe { ::core::mem::transmute(val) };
          }

          match val {
            0 => Status::Unknown,
            1 => Status::Upcoming,
            2 => Status::Ongoing,
            3 => Status::Completed,
            4 => Status::Cancelled,
            5 => Status::Paused,

            _ => panic!("invalid enum discriminant"),
          }
        }
      }

      #[repr(u8)]
      #[derive(Clone, Copy, Eq, Ord, PartialEq, PartialOrd)]
      pub enum CardLayout {
        Carousel,
        Grid,
        VerticalList,
        Banner,
        Compact,
      }
      impl ::core::fmt::Debug for CardLayout {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          match self {
            CardLayout::Carousel => {
              f.debug_tuple("CardLayout::Carousel").finish()
            }
            CardLayout::Grid => {
              f.debug_tuple("CardLayout::Grid").finish()
            }
            CardLayout::VerticalList => {
              f.debug_tuple("CardLayout::VerticalList").finish()
            }
            CardLayout::Banner => {
              f.debug_tuple("CardLayout::Banner").finish()
            }
            CardLayout::Compact => {
              f.debug_tuple("CardLayout::Compact").finish()
            }
          }
        }
      }

      impl CardLayout{
        #[doc(hidden)]
        pub unsafe fn _lift(val: u8) -> CardLayout{
          if !cfg!(debug_assertions) {
            return unsafe { ::core::mem::transmute(val) };
          }

          match val {
            0 => CardLayout::Carousel,
            1 => CardLayout::Grid,
            2 => CardLayout::VerticalList,
            3 => CardLayout::Banner,
            4 => CardLayout::Compact,

            _ => panic!("invalid enum discriminant"),
          }
        }
      }

      #[derive(Clone)]
      pub struct PageCursor {
        pub token: Option<_rt::String>,
        pub limit: Option<u32>,
      }
      impl ::core::fmt::Debug for PageCursor {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          f.debug_struct("PageCursor").field("token", &self.token).field("limit", &self.limit).finish()
        }
      }
      #[derive(Clone)]
      pub struct MediaCard {
        pub id: _rt::String,
        pub title: _rt::String,
        pub kind: Option<MediaKind>,
        pub images: Option<ImageSet>,
        pub original_title: Option<_rt::String>,
        pub tagline: Option<_rt::String>,
        pub year: Option<_rt::String>,
        pub score: Option<u32>,
        pub genres: _rt::Vec::<_rt::String>,
        pub status: Option<Status>,
        pub content_rating: Option<_rt::String>,
        pub url: Option<_rt::String>,
        pub ids: _rt::Vec::<LinkedId>,
        pub extra: _rt::Vec::<Attr>,
      }
      impl ::core::fmt::Debug for MediaCard {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          f.debug_struct("MediaCard").field("id", &self.id).field("title", &self.title).field("kind", &self.kind).field("images", &self.images).field("original-title", &self.original_title).field("tagline", &self.tagline).field("year", &self.year).field("score", &self.score).field("genres", &self.genres).field("status", &self.status).field("content-rating", &self.content_rating).field("url", &self.url).field("ids", &self.ids).field("extra", &self.extra).finish()
        }
      }
      #[derive(Clone)]
      pub struct CategoryLink {
        pub id: _rt::String,
        pub title: _rt::String,
        pub subtitle: Option<_rt::String>,
        pub image: Option<Image>,
      }
      impl ::core::fmt::Debug for CategoryLink {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          f.debug_struct("CategoryLink").field("id", &self.id).field("title", &self.title).field("subtitle", &self.subtitle).field("image", &self.image).finish()
        }
      }
      #[derive(Clone)]
      pub struct HomeSection {
        pub id: _rt::String,
        pub title: _rt::String,
        pub subtitle: Option<_rt::String>,
        pub items: _rt::Vec::<MediaCard>,
        pub next_page: Option<_rt::String>,
        pub layout: CardLayout,
        pub show_rank: bool,
        pub categories: _rt::Vec::<CategoryLink>,
        pub extra: _rt::Vec::<Attr>,
      }
      impl ::core::fmt::Debug for HomeSection {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          f.debug_struct("HomeSection").field("id", &self.id).field("title", &self.title).field("subtitle", &self.subtitle).field("items", &self.items).field("next-page", &self.next_page).field("layout", &self.layout).field("show-rank", &self.show_rank).field("categories", &self.categories).field("extra", &self.extra).finish()
        }
      }
      #[derive(Clone)]
      pub struct PagedResult {
        pub items: _rt::Vec::<MediaCard>,
        pub categories: _rt::Vec::<CategoryLink>,
        pub next_page: Option<_rt::String>,
      }
      impl ::core::fmt::Debug for PagedResult {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          f.debug_struct("PagedResult").field("items", &self.items).field("categories", &self.categories).field("next-page", &self.next_page).finish()
        }
      }
      #[derive(Clone)]
      pub struct SearchFilters {
        pub kind: Option<MediaKind>,
        pub page: PageCursor,
        pub fast_match: bool,
      }
      impl ::core::fmt::Debug for SearchFilters {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          f.debug_struct("SearchFilters").field("kind", &self.kind).field("page", &self.page).field("fast-match", &self.fast_match).finish()
        }
      }
      #[derive(Clone)]
      pub struct Episode {
        pub id: _rt::String,
        pub title: _rt::String,
        pub number: Option<f64>,
        pub season: Option<f64>,
        pub images: Option<ImageSet>,
        pub description: Option<_rt::String>,
        pub released: Option<_rt::String>,
        pub score: Option<u32>,
        pub url: Option<_rt::String>,
        pub tags: _rt::Vec::<_rt::String>,
        pub extra: _rt::Vec::<Attr>,
      }
      impl ::core::fmt::Debug for Episode {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          f.debug_struct("Episode").field("id", &self.id).field("title", &self.title).field("number", &self.number).field("season", &self.season).field("images", &self.images).field("description", &self.description).field("released", &self.released).field("score", &self.score).field("url", &self.url).field("tags", &self.tags).field("extra", &self.extra).finish()
        }
      }
      #[derive(Clone)]
      pub struct Season {
        pub id: _rt::String,
        pub title: _rt::String,
        pub number: Option<f64>,
        pub year: Option<u32>,
        pub episodes: _rt::Vec::<Episode>,
      }
      impl ::core::fmt::Debug for Season {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          f.debug_struct("Season").field("id", &self.id).field("title", &self.title).field("number", &self.number).field("year", &self.year).field("episodes", &self.episodes).finish()
        }
      }
      #[derive(Clone)]
      pub struct Person {
        pub id: _rt::String,
        pub name: _rt::String,
        pub image: Option<ImageSet>,
        pub role: Option<_rt::String>,
        pub url: Option<_rt::String>,
      }
      impl ::core::fmt::Debug for Person {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          f.debug_struct("Person").field("id", &self.id).field("name", &self.name).field("image", &self.image).field("role", &self.role).field("url", &self.url).finish()
        }
      }
      #[derive(Clone)]
      pub struct MediaInfo {
        pub id: _rt::String,
        pub title: _rt::String,
        pub kind: MediaKind,
        pub images: Option<ImageSet>,
        pub original_title: Option<_rt::String>,
        pub description: Option<_rt::String>,
        pub score: Option<u32>,
        pub scored_by: Option<u64>,
        pub year: Option<_rt::String>,
        pub release_date: Option<_rt::String>,
        pub genres: _rt::Vec::<_rt::String>,
        pub tags: _rt::Vec::<_rt::String>,
        pub status: Option<Status>,
        pub content_rating: Option<_rt::String>,
        pub seasons: _rt::Vec::<Season>,
        pub cast: _rt::Vec::<Person>,
        pub crew: _rt::Vec::<Person>,
        pub runtime_minutes: Option<u32>,
        pub trailer_url: Option<_rt::String>,
        pub ids: _rt::Vec::<LinkedId>,
        pub studio: Option<_rt::String>,
        pub country: Option<_rt::String>,
        pub language: Option<_rt::String>,
        pub url: Option<_rt::String>,
        pub extra: _rt::Vec::<Attr>,
      }
      impl ::core::fmt::Debug for MediaInfo {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          f.debug_struct("MediaInfo").field("id", &self.id).field("title", &self.title).field("kind", &self.kind).field("images", &self.images).field("original-title", &self.original_title).field("description", &self.description).field("score", &self.score).field("scored-by", &self.scored_by).field("year", &self.year).field("release-date", &self.release_date).field("genres", &self.genres).field("tags", &self.tags).field("status", &self.status).field("content-rating", &self.content_rating).field("seasons", &self.seasons).field("cast", &self.cast).field("crew", &self.crew).field("runtime-minutes", &self.runtime_minutes).field("trailer-url", &self.trailer_url).field("ids", &self.ids).field("studio", &self.studio).field("country", &self.country).field("language", &self.language).field("url", &self.url).field("extra", &self.extra).finish()
        }
      }
      #[derive(Clone)]
      pub struct VideoResolution {
        pub width: u32,
        pub height: u32,
        pub hdr: bool,
        pub label: _rt::String,
      }
      impl ::core::fmt::Debug for VideoResolution {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          f.debug_struct("VideoResolution").field("width", &self.width).field("height", &self.height).field("hdr", &self.hdr).field("label", &self.label).finish()
        }
      }
      #[repr(u8)]
      #[derive(Clone, Copy, Eq, Ord, PartialEq, PartialOrd)]
      pub enum StreamFormat {
        Hls,
        Dash,
        Progressive,
        Unknown,
      }
      impl ::core::fmt::Debug for StreamFormat {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          match self {
            StreamFormat::Hls => {
              f.debug_tuple("StreamFormat::Hls").finish()
            }
            StreamFormat::Dash => {
              f.debug_tuple("StreamFormat::Dash").finish()
            }
            StreamFormat::Progressive => {
              f.debug_tuple("StreamFormat::Progressive").finish()
            }
            StreamFormat::Unknown => {
              f.debug_tuple("StreamFormat::Unknown").finish()
            }
          }
        }
      }

      impl StreamFormat{
        #[doc(hidden)]
        pub unsafe fn _lift(val: u8) -> StreamFormat{
          if !cfg!(debug_assertions) {
            return unsafe { ::core::mem::transmute(val) };
          }

          match val {
            0 => StreamFormat::Hls,
            1 => StreamFormat::Dash,
            2 => StreamFormat::Progressive,
            3 => StreamFormat::Unknown,

            _ => panic!("invalid enum discriminant"),
          }
        }
      }

      #[derive(Clone)]
      pub struct VideoTrack {
        pub resolution: VideoResolution,
        pub url: _rt::String,
        pub mime_type: Option<_rt::String>,
        pub bitrate: Option<u64>,
        pub codecs: Option<_rt::String>,
      }
      impl ::core::fmt::Debug for VideoTrack {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          f.debug_struct("VideoTrack").field("resolution", &self.resolution).field("url", &self.url).field("mime-type", &self.mime_type).field("bitrate", &self.bitrate).field("codecs", &self.codecs).finish()
        }
      }
      #[derive(Clone)]
      pub struct SubtitleTrack {
        pub label: _rt::String,
        pub url: _rt::String,
        pub language: Option<_rt::String>,
        pub format: Option<_rt::String>,
      }
      impl ::core::fmt::Debug for SubtitleTrack {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          f.debug_struct("SubtitleTrack").field("label", &self.label).field("url", &self.url).field("language", &self.language).field("format", &self.format).finish()
        }
      }
      #[derive(Clone)]
      pub struct Server {
        pub id: _rt::String,
        pub label: _rt::String,
        pub url: _rt::String,
        pub priority: u8,
        pub extra: _rt::Vec::<Attr>,
      }
      impl ::core::fmt::Debug for Server {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          f.debug_struct("Server").field("id", &self.id).field("label", &self.label).field("url", &self.url).field("priority", &self.priority).field("extra", &self.extra).finish()
        }
      }
      #[derive(Clone)]
      pub struct StreamSource {
        pub id: _rt::String,
        pub label: _rt::String,
        pub format: StreamFormat,
        pub manifest_url: Option<_rt::String>,
        pub videos: _rt::Vec::<VideoTrack>,
        pub subtitles: _rt::Vec::<SubtitleTrack>,
        pub headers: _rt::Vec::<Attr>,
        pub extra: _rt::Vec::<Attr>,
      }
      impl ::core::fmt::Debug for StreamSource {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          f.debug_struct("StreamSource").field("id", &self.id).field("label", &self.label).field("format", &self.format).field("manifest-url", &self.manifest_url).field("videos", &self.videos).field("subtitles", &self.subtitles).field("headers", &self.headers).field("extra", &self.extra).finish()
        }
      }
      #[derive(Clone)]
      pub struct SubtitleQuery {
        pub title: Option<_rt::String>,
        pub year: Option<u32>,
        pub season: Option<u32>,
        pub episode: Option<u32>,
        pub language: Option<_rt::String>,
        pub fps: Option<f32>,
        pub file_hash: Option<_rt::String>,
        pub file_size: Option<u64>,
        pub identifiers: _rt::Vec::<LinkedId>,
      }
      impl ::core::fmt::Debug for SubtitleQuery {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          f.debug_struct("SubtitleQuery").field("title", &self.title).field("year", &self.year).field("season", &self.season).field("episode", &self.episode).field("language", &self.language).field("fps", &self.fps).field("file-hash", &self.file_hash).field("file-size", &self.file_size).field("identifiers", &self.identifiers).finish()
        }
      }
      #[derive(Clone)]
      pub struct SubtitleEntry {
        pub id: _rt::String,
        pub title: _rt::String,
        pub language: _rt::String,
        pub format: _rt::String,
        pub url: Option<_rt::String>,
        pub release: Option<_rt::String>,
        pub fps: Option<f32>,
        pub downloads: Option<u64>,
        pub score: Option<u32>,
        pub hearing_impaired: bool,
        pub machine_translated: bool,
        pub file_hash: Option<_rt::String>,
        pub extra: _rt::Vec::<Attr>,
      }
      impl ::core::fmt::Debug for SubtitleEntry {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          f.debug_struct("SubtitleEntry").field("id", &self.id).field("title", &self.title).field("language", &self.language).field("format", &self.format).field("url", &self.url).field("release", &self.release).field("fps", &self.fps).field("downloads", &self.downloads).field("score", &self.score).field("hearing-impaired", &self.hearing_impaired).field("machine-translated", &self.machine_translated).field("file-hash", &self.file_hash).field("extra", &self.extra).finish()
        }
      }
      #[derive(Clone)]
      pub struct SubtitleFile {
        pub format: _rt::String,
        pub content: _rt::Vec::<u8>,
      }
      impl ::core::fmt::Debug for SubtitleFile {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          f.debug_struct("SubtitleFile").field("format", &self.format).field("content", &self.content).finish()
        }
      }
      #[derive(Clone)]
      pub struct Article {
        pub id: _rt::String,
        pub title: _rt::String,
        pub summary: Option<_rt::String>,
        pub url: _rt::String,
        pub published: Option<_rt::String>,
        pub author: Option<_rt::String>,
        pub thumbnail: Option<ImageSet>,
        pub tags: _rt::Vec::<_rt::String>,
        pub extra: _rt::Vec::<Attr>,
      }
      impl ::core::fmt::Debug for Article {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          f.debug_struct("Article").field("id", &self.id).field("title", &self.title).field("summary", &self.summary).field("url", &self.url).field("published", &self.published).field("author", &self.author).field("thumbnail", &self.thumbnail).field("tags", &self.tags).field("extra", &self.extra).finish()
        }
      }
      #[derive(Clone)]
      pub struct ArticleSection {
        pub id: _rt::String,
        pub title: _rt::String,
        pub items: _rt::Vec::<Article>,
        pub next_page: Option<_rt::String>,
      }
      impl ::core::fmt::Debug for ArticleSection {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          f.debug_struct("ArticleSection").field("id", &self.id).field("title", &self.title).field("items", &self.items).field("next-page", &self.next_page).finish()
        }
      }
      #[derive(Clone)]
      pub enum PluginError {
        Network(_rt::String),
        Parse(_rt::String),
        NotFound,
        Unauthorized,
        Forbidden,
        RateLimited(Option<u32>),
        Timeout,
        Cancelled,
        Unsupported,
        InvalidInput(_rt::String),
        Internal(_rt::String),
      }
      impl ::core::fmt::Debug for PluginError {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          match self {
            PluginError::Network(e) => {
              f.debug_tuple("PluginError::Network").field(e).finish()
            }
            PluginError::Parse(e) => {
              f.debug_tuple("PluginError::Parse").field(e).finish()
            }
            PluginError::NotFound => {
              f.debug_tuple("PluginError::NotFound").finish()
            }
            PluginError::Unauthorized => {
              f.debug_tuple("PluginError::Unauthorized").finish()
            }
            PluginError::Forbidden => {
              f.debug_tuple("PluginError::Forbidden").finish()
            }
            PluginError::RateLimited(e) => {
              f.debug_tuple("PluginError::RateLimited").field(e).finish()
            }
            PluginError::Timeout => {
              f.debug_tuple("PluginError::Timeout").finish()
            }
            PluginError::Cancelled => {
              f.debug_tuple("PluginError::Cancelled").finish()
            }
            PluginError::Unsupported => {
              f.debug_tuple("PluginError::Unsupported").finish()
            }
            PluginError::InvalidInput(e) => {
              f.debug_tuple("PluginError::InvalidInput").field(e).finish()
            }
            PluginError::Internal(e) => {
              f.debug_tuple("PluginError::Internal").field(e).finish()
            }
          }
        }
      }
      impl ::core::fmt::Display for PluginError {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          write!(f, "{:?}", self)
        }
      }

      impl ::core::error::Error for PluginError {}

    }


    #[allow(dead_code, async_fn_in_trait, unused_imports, clippy::all)]
    pub mod http {
      #[used]
      #[doc(hidden)]
      static __FORCE_SECTION_REF: fn() =
      super::super::super::__link_custom_section_describing_imports;
      
      use super::super::super::_rt;
      pub type Attr = super::super::super::bex::plugin::common::Attr;
      pub type PluginError = super::super::super::bex::plugin::common::PluginError;
      #[repr(u8)]
      #[derive(Clone, Copy, Eq, Ord, PartialEq, PartialOrd)]
      pub enum Method {
        Get,
        Post,
        Put,
        Delete,
        Head,
        Patch,
        Options,
      }
      impl ::core::fmt::Debug for Method {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          match self {
            Method::Get => {
              f.debug_tuple("Method::Get").finish()
            }
            Method::Post => {
              f.debug_tuple("Method::Post").finish()
            }
            Method::Put => {
              f.debug_tuple("Method::Put").finish()
            }
            Method::Delete => {
              f.debug_tuple("Method::Delete").finish()
            }
            Method::Head => {
              f.debug_tuple("Method::Head").finish()
            }
            Method::Patch => {
              f.debug_tuple("Method::Patch").finish()
            }
            Method::Options => {
              f.debug_tuple("Method::Options").finish()
            }
          }
        }
      }

      impl Method{
        #[doc(hidden)]
        pub unsafe fn _lift(val: u8) -> Method{
          if !cfg!(debug_assertions) {
            return unsafe { ::core::mem::transmute(val) };
          }

          match val {
            0 => Method::Get,
            1 => Method::Post,
            2 => Method::Put,
            3 => Method::Delete,
            4 => Method::Head,
            5 => Method::Patch,
            6 => Method::Options,

            _ => panic!("invalid enum discriminant"),
          }
        }
      }

      #[repr(u8)]
      #[derive(Clone, Copy, Eq, Ord, PartialEq, PartialOrd)]
      pub enum CacheMode {
        Normal,
        NoStore,
        OnlyCache,
        ForceRefresh,
      }
      impl ::core::fmt::Debug for CacheMode {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          match self {
            CacheMode::Normal => {
              f.debug_tuple("CacheMode::Normal").finish()
            }
            CacheMode::NoStore => {
              f.debug_tuple("CacheMode::NoStore").finish()
            }
            CacheMode::OnlyCache => {
              f.debug_tuple("CacheMode::OnlyCache").finish()
            }
            CacheMode::ForceRefresh => {
              f.debug_tuple("CacheMode::ForceRefresh").finish()
            }
          }
        }
      }

      impl CacheMode{
        #[doc(hidden)]
        pub unsafe fn _lift(val: u8) -> CacheMode{
          if !cfg!(debug_assertions) {
            return unsafe { ::core::mem::transmute(val) };
          }

          match val {
            0 => CacheMode::Normal,
            1 => CacheMode::NoStore,
            2 => CacheMode::OnlyCache,
            3 => CacheMode::ForceRefresh,

            _ => panic!("invalid enum discriminant"),
          }
        }
      }

      #[derive(Clone)]
      pub struct Request {
        pub method: Method,
        pub url: _rt::String,
        pub headers: _rt::Vec::<Attr>,
        pub body: Option<_rt::Vec::<u8>>,
        pub timeout_ms: Option<u32>,
        pub follow_redirects: bool,
        pub cache_mode: CacheMode,
        pub max_bytes: Option<u64>,
      }
      impl ::core::fmt::Debug for Request {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          f.debug_struct("Request").field("method", &self.method).field("url", &self.url).field("headers", &self.headers).field("body", &self.body).field("timeout-ms", &self.timeout_ms).field("follow-redirects", &self.follow_redirects).field("cache-mode", &self.cache_mode).field("max-bytes", &self.max_bytes).finish()
        }
      }
      #[derive(Clone)]
      pub struct Response {
        pub status: u16,
        pub headers: _rt::Vec::<Attr>,
        pub body: _rt::Vec::<u8>,
        pub cached: bool,
        pub final_url: _rt::String,
      }
      impl ::core::fmt::Debug for Response {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          f.debug_struct("Response").field("status", &self.status).field("headers", &self.headers).field("body", &self.body).field("cached", &self.cached).field("final-url", &self.final_url).finish()
        }
      }
      #[allow(unused_unsafe, clippy::all)]
      /// Send an HTTP request and return the response.
      /// This is a simple function-based API (no resource types) for simplicity.
      #[allow(async_fn_in_trait)]
      pub fn send_request(req: &Request,) -> Result<Response,PluginError>{
        unsafe {

          #[cfg_attr(target_pointer_width="64", repr(align(8)))]
          #[cfg_attr(target_pointer_width="32", repr(align(4)))]
          struct RetArea([::core::mem::MaybeUninit::<u8>; 9*::core::mem::size_of::<*const u8>()]);
          let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 9*::core::mem::size_of::<*const u8>()]);
          let Request{ method:method0, url:url0, headers:headers0, body:body0, timeout_ms:timeout_ms0, follow_redirects:follow_redirects0, cache_mode:cache_mode0, max_bytes:max_bytes0, } = req;
          let vec1 = url0;
          let ptr1 = vec1.as_ptr().cast::<u8>();
          let len1 = vec1.len();
          let vec5 = headers0;
          let len5 = vec5.len();
          let layout5 = _rt::alloc::Layout::from_size_align(vec5.len() * (4*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>()).unwrap();
          let (result5, _cleanup5) = wit_bindgen::rt::Cleanup::new(layout5);for (i, e) in vec5.into_iter().enumerate() {
            let base = result5.add(i * (4*::core::mem::size_of::<*const u8>()));
            {
              let super::super::super::bex::plugin::common::Attr{ key:key2, value:value2, } = e;
              let vec3 = key2;
              let ptr3 = vec3.as_ptr().cast::<u8>();
              let len3 = vec3.len();
              *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len3;
              *base.add(0).cast::<*mut u8>() = ptr3.cast_mut();
              let vec4 = value2;
              let ptr4 = vec4.as_ptr().cast::<u8>();
              let len4 = vec4.len();
              *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len4;
              *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr4.cast_mut();
            }
          }
          let (result7_0,result7_1,result7_2,) = match body0 {
            Some(e) => {
              let vec6 = e;
              let ptr6 = vec6.as_ptr().cast::<u8>();
              let len6 = vec6.len();

              (1i32, ptr6.cast_mut(), len6)
            },
            None => {
              (0i32, ::core::ptr::null_mut(), 0usize)
            },
          };let (result8_0,result8_1,) = match timeout_ms0 {
            Some(e) => (1i32, _rt::as_i32(e)),
            None => {
              (0i32, 0i32)
            },
          };let (result9_0,result9_1,) = match max_bytes0 {
            Some(e) => (1i32, _rt::as_i64(e)),
            None => {
              (0i32, 0i64)
            },
          };let ptr10 = ret_area.0.as_mut_ptr().cast::<u8>();
          #[cfg(target_arch = "wasm32")]
          #[link(wasm_import_module = "bex:plugin/http@1.0.0")]
          unsafe extern "C" {
            #[link_name = "send-request"]
            fn wit_import11(_: i32, _: *mut u8, _: usize, _: *mut u8, _: usize, _: i32, _: *mut u8, _: usize, _: i32, _: i32, _: i32, _: i32, _: i32, _: i64, _: *mut u8, );
          }

          #[cfg(not(target_arch = "wasm32"))]
          unsafe extern "C" fn wit_import11(_: i32, _: *mut u8, _: usize, _: *mut u8, _: usize, _: i32, _: *mut u8, _: usize, _: i32, _: i32, _: i32, _: i32, _: i32, _: i64, _: *mut u8, ) { unreachable!() }
          wit_import11(method0.clone() as i32, ptr1.cast_mut(), len1, result5, len5, result7_0, result7_1, result7_2, result8_0, result8_1, match follow_redirects0 { true => 1, false => 0 }, cache_mode0.clone() as i32, result9_0, result9_1, ptr10);
          let l12 = i32::from(*ptr10.add(0).cast::<u8>());
          let result46 = match l12 {
            0 => {
              let e = {
                let l13 = i32::from(*ptr10.add(::core::mem::size_of::<*const u8>()).cast::<u16>());
                let l14 = *ptr10.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                let l15 = *ptr10.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                let base22 = l14;
                let len22 = l15;
                let mut result22 = _rt::Vec::with_capacity(len22);
                for i in 0..len22 {
                  let base = base22.add(i * (4*::core::mem::size_of::<*const u8>()));
                  let e22 = {
                    let l16 = *base.add(0).cast::<*mut u8>();
                    let l17 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                    let len18 = l17;
                    let bytes18 = _rt::Vec::from_raw_parts(l16.cast(), len18, len18);
                    let l19 = *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                    let l20 = *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                    let len21 = l20;
                    let bytes21 = _rt::Vec::from_raw_parts(l19.cast(), len21, len21);

                    super::super::super::bex::plugin::common::Attr{
                      key: _rt::string_lift(bytes18),
                      value: _rt::string_lift(bytes21),
                    }
                  };
                  result22.push(e22);
                }
                _rt::cabi_dealloc(base22, len22 * (4*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                let l23 = *ptr10.add(4*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                let l24 = *ptr10.add(5*::core::mem::size_of::<*const u8>()).cast::<usize>();
                let len25 = l24;
                let l26 = i32::from(*ptr10.add(6*::core::mem::size_of::<*const u8>()).cast::<u8>());
                let l27 = *ptr10.add(7*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                let l28 = *ptr10.add(8*::core::mem::size_of::<*const u8>()).cast::<usize>();
                let len29 = l28;
                let bytes29 = _rt::Vec::from_raw_parts(l27.cast(), len29, len29);

                Response{
                  status: l13 as u16,
                  headers: result22,
                  body: <_ as From<_rt::Vec<_>>>::from(_rt::Vec::from_raw_parts(l23.cast(), len25, len25)),
                  cached: _rt::bool_lift(l26 as u8),
                  final_url: _rt::string_lift(bytes29),
                }
              };
              Ok(e)
            }
            1 => {
              let e = {
                let l30 = i32::from(*ptr10.add(::core::mem::size_of::<*const u8>()).cast::<u8>());
                use super::super::super::bex::plugin::common::PluginError as V45;
                let v45 = match l30 {
                  0 => {
                    let e45 = {
                      let l31 = *ptr10.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                      let l32 = *ptr10.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                      let len33 = l32;
                      let bytes33 = _rt::Vec::from_raw_parts(l31.cast(), len33, len33);

                      _rt::string_lift(bytes33)
                    };
                    V45::Network(e45)
                  }
                  1 => {
                    let e45 = {
                      let l34 = *ptr10.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                      let l35 = *ptr10.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                      let len36 = l35;
                      let bytes36 = _rt::Vec::from_raw_parts(l34.cast(), len36, len36);

                      _rt::string_lift(bytes36)
                    };
                    V45::Parse(e45)
                  }
                  2 => {
                    V45::NotFound
                  }
                  3 => {
                    V45::Unauthorized
                  }
                  4 => {
                    V45::Forbidden
                  }
                  5 => {
                    let e45 = {
                      let l37 = i32::from(*ptr10.add(2*::core::mem::size_of::<*const u8>()).cast::<u8>());

                      match l37 {
                        0 => None,
                        1 => {
                          let e = {
                            let l38 = *ptr10.add(4+2*::core::mem::size_of::<*const u8>()).cast::<i32>();

                            l38 as u32
                          };
                          Some(e)
                        }
                        _ => _rt::invalid_enum_discriminant(),
                      }
                    };
                    V45::RateLimited(e45)
                  }
                  6 => {
                    V45::Timeout
                  }
                  7 => {
                    V45::Cancelled
                  }
                  8 => {
                    V45::Unsupported
                  }
                  9 => {
                    let e45 = {
                      let l39 = *ptr10.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                      let l40 = *ptr10.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                      let len41 = l40;
                      let bytes41 = _rt::Vec::from_raw_parts(l39.cast(), len41, len41);

                      _rt::string_lift(bytes41)
                    };
                    V45::InvalidInput(e45)
                  }
                  n => {
                    debug_assert_eq!(n, 10, "invalid enum discriminant");
                    let e45 = {
                      let l42 = *ptr10.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                      let l43 = *ptr10.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                      let len44 = l43;
                      let bytes44 = _rt::Vec::from_raw_parts(l42.cast(), len44, len44);

                      _rt::string_lift(bytes44)
                    };
                    V45::Internal(e45)
                  }
                };

                v45
              };
              Err(e)
            }
            _ => _rt::invalid_enum_discriminant(),
          };
          result46
        }
      }

    }


    #[allow(dead_code, async_fn_in_trait, unused_imports, clippy::all)]
    pub mod kv {
      #[used]
      #[doc(hidden)]
      static __FORCE_SECTION_REF: fn() =
      super::super::super::__link_custom_section_describing_imports;
      
      use super::super::super::_rt;
      pub type Attr = super::super::super::bex::plugin::common::Attr;
      #[allow(unused_unsafe, clippy::all)]
      #[allow(async_fn_in_trait)]
      pub fn set(key: &str,value: &[u8],ttl_seconds: Option<u32>,) -> bool{
        unsafe {
          let vec0 = key;
          let ptr0 = vec0.as_ptr().cast::<u8>();
          let len0 = vec0.len();
          let vec1 = value;
          let ptr1 = vec1.as_ptr().cast::<u8>();
          let len1 = vec1.len();
          let (result2_0,result2_1,) = match ttl_seconds {
            Some(e) => (1i32, _rt::as_i32(e)),
            None => {
              (0i32, 0i32)
            },
          };
          #[cfg(target_arch = "wasm32")]
          #[link(wasm_import_module = "bex:plugin/kv@1.0.0")]
          unsafe extern "C" {
            #[link_name = "set"]
            fn wit_import3(_: *mut u8, _: usize, _: *mut u8, _: usize, _: i32, _: i32, ) -> i32;
          }

          #[cfg(not(target_arch = "wasm32"))]
          unsafe extern "C" fn wit_import3(_: *mut u8, _: usize, _: *mut u8, _: usize, _: i32, _: i32, ) -> i32 { unreachable!() }
          let ret = wit_import3(ptr0.cast_mut(), len0, ptr1.cast_mut(), len1, result2_0, result2_1);
          _rt::bool_lift(ret as u8)
        }
      }
      #[allow(unused_unsafe, clippy::all)]
      #[allow(async_fn_in_trait)]
      pub fn get(key: &str,) -> Option<_rt::Vec::<u8>>{
        unsafe {

          #[cfg_attr(target_pointer_width="64", repr(align(8)))]
          #[cfg_attr(target_pointer_width="32", repr(align(4)))]
          struct RetArea([::core::mem::MaybeUninit::<u8>; 3*::core::mem::size_of::<*const u8>()]);
          let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 3*::core::mem::size_of::<*const u8>()]);
          let vec0 = key;
          let ptr0 = vec0.as_ptr().cast::<u8>();
          let len0 = vec0.len();
          let ptr1 = ret_area.0.as_mut_ptr().cast::<u8>();
          #[cfg(target_arch = "wasm32")]
          #[link(wasm_import_module = "bex:plugin/kv@1.0.0")]
          unsafe extern "C" {
            #[link_name = "get"]
            fn wit_import2(_: *mut u8, _: usize, _: *mut u8, );
          }

          #[cfg(not(target_arch = "wasm32"))]
          unsafe extern "C" fn wit_import2(_: *mut u8, _: usize, _: *mut u8, ) { unreachable!() }
          wit_import2(ptr0.cast_mut(), len0, ptr1);
          let l3 = i32::from(*ptr1.add(0).cast::<u8>());
          let result7 = match l3 {
            0 => None,
            1 => {
              let e = {
                let l4 = *ptr1.add(::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                let l5 = *ptr1.add(2*::core::mem::size_of::<*const u8>()).cast::<usize>();
                let len6 = l5;

                <_ as From<_rt::Vec<_>>>::from(_rt::Vec::from_raw_parts(l4.cast(), len6, len6))
              };
              Some(e)
            }
            _ => _rt::invalid_enum_discriminant(),
          };
          result7
        }
      }
      #[allow(unused_unsafe, clippy::all)]
      #[allow(async_fn_in_trait)]
      pub fn remove(key: &str,) -> bool{
        unsafe {
          let vec0 = key;
          let ptr0 = vec0.as_ptr().cast::<u8>();
          let len0 = vec0.len();

          #[cfg(target_arch = "wasm32")]
          #[link(wasm_import_module = "bex:plugin/kv@1.0.0")]
          unsafe extern "C" {
            #[link_name = "remove"]
            fn wit_import1(_: *mut u8, _: usize, ) -> i32;
          }

          #[cfg(not(target_arch = "wasm32"))]
          unsafe extern "C" fn wit_import1(_: *mut u8, _: usize, ) -> i32 { unreachable!() }
          let ret = wit_import1(ptr0.cast_mut(), len0);
          _rt::bool_lift(ret as u8)
        }
      }
      #[allow(unused_unsafe, clippy::all)]
      #[allow(async_fn_in_trait)]
      pub fn keys(prefix: &str,) -> _rt::Vec::<_rt::String>{
        unsafe {

          #[cfg_attr(target_pointer_width="64", repr(align(8)))]
          #[cfg_attr(target_pointer_width="32", repr(align(4)))]
          struct RetArea([::core::mem::MaybeUninit::<u8>; 2*::core::mem::size_of::<*const u8>()]);
          let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 2*::core::mem::size_of::<*const u8>()]);
          let vec0 = prefix;
          let ptr0 = vec0.as_ptr().cast::<u8>();
          let len0 = vec0.len();
          let ptr1 = ret_area.0.as_mut_ptr().cast::<u8>();
          #[cfg(target_arch = "wasm32")]
          #[link(wasm_import_module = "bex:plugin/kv@1.0.0")]
          unsafe extern "C" {
            #[link_name = "keys"]
            fn wit_import2(_: *mut u8, _: usize, _: *mut u8, );
          }

          #[cfg(not(target_arch = "wasm32"))]
          unsafe extern "C" fn wit_import2(_: *mut u8, _: usize, _: *mut u8, ) { unreachable!() }
          wit_import2(ptr0.cast_mut(), len0, ptr1);
          let l3 = *ptr1.add(0).cast::<*mut u8>();
          let l4 = *ptr1.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
          let base8 = l3;
          let len8 = l4;
          let mut result8 = _rt::Vec::with_capacity(len8);
          for i in 0..len8 {
            let base = base8.add(i * (2*::core::mem::size_of::<*const u8>()));
            let e8 = {
              let l5 = *base.add(0).cast::<*mut u8>();
              let l6 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
              let len7 = l6;
              let bytes7 = _rt::Vec::from_raw_parts(l5.cast(), len7, len7);

              _rt::string_lift(bytes7)
            };
            result8.push(e8);
          }
          _rt::cabi_dealloc(base8, len8 * (2*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
          let result9 = result8;
          result9
        }
      }

    }


    #[allow(dead_code, async_fn_in_trait, unused_imports, clippy::all)]
    pub mod secrets {
      #[used]
      #[doc(hidden)]
      static __FORCE_SECTION_REF: fn() =
      super::super::super::__link_custom_section_describing_imports;
      
      use super::super::super::_rt;
      #[allow(unused_unsafe, clippy::all)]
      #[allow(async_fn_in_trait)]
      pub fn get(key: &str,) -> Option<_rt::String>{
        unsafe {

          #[cfg_attr(target_pointer_width="64", repr(align(8)))]
          #[cfg_attr(target_pointer_width="32", repr(align(4)))]
          struct RetArea([::core::mem::MaybeUninit::<u8>; 3*::core::mem::size_of::<*const u8>()]);
          let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 3*::core::mem::size_of::<*const u8>()]);
          let vec0 = key;
          let ptr0 = vec0.as_ptr().cast::<u8>();
          let len0 = vec0.len();
          let ptr1 = ret_area.0.as_mut_ptr().cast::<u8>();
          #[cfg(target_arch = "wasm32")]
          #[link(wasm_import_module = "bex:plugin/secrets@1.0.0")]
          unsafe extern "C" {
            #[link_name = "get"]
            fn wit_import2(_: *mut u8, _: usize, _: *mut u8, );
          }

          #[cfg(not(target_arch = "wasm32"))]
          unsafe extern "C" fn wit_import2(_: *mut u8, _: usize, _: *mut u8, ) { unreachable!() }
          wit_import2(ptr0.cast_mut(), len0, ptr1);
          let l3 = i32::from(*ptr1.add(0).cast::<u8>());
          let result7 = match l3 {
            0 => None,
            1 => {
              let e = {
                let l4 = *ptr1.add(::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                let l5 = *ptr1.add(2*::core::mem::size_of::<*const u8>()).cast::<usize>();
                let len6 = l5;
                let bytes6 = _rt::Vec::from_raw_parts(l4.cast(), len6, len6);

                _rt::string_lift(bytes6)
              };
              Some(e)
            }
            _ => _rt::invalid_enum_discriminant(),
          };
          result7
        }
      }

    }


    #[allow(dead_code, async_fn_in_trait, unused_imports, clippy::all)]
    pub mod log {
      #[used]
      #[doc(hidden)]
      static __FORCE_SECTION_REF: fn() =
      super::super::super::__link_custom_section_describing_imports;
      
      use super::super::super::_rt;
      pub type Attr = super::super::super::bex::plugin::common::Attr;
      #[repr(u8)]
      #[derive(Clone, Copy, Eq, Ord, PartialEq, PartialOrd)]
      pub enum Level {
        Trace,
        Debug,
        Info,
        Warn,
        Error,
      }
      impl ::core::fmt::Debug for Level {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          match self {
            Level::Trace => {
              f.debug_tuple("Level::Trace").finish()
            }
            Level::Debug => {
              f.debug_tuple("Level::Debug").finish()
            }
            Level::Info => {
              f.debug_tuple("Level::Info").finish()
            }
            Level::Warn => {
              f.debug_tuple("Level::Warn").finish()
            }
            Level::Error => {
              f.debug_tuple("Level::Error").finish()
            }
          }
        }
      }

      impl Level{
        #[doc(hidden)]
        pub unsafe fn _lift(val: u8) -> Level{
          if !cfg!(debug_assertions) {
            return unsafe { ::core::mem::transmute(val) };
          }

          match val {
            0 => Level::Trace,
            1 => Level::Debug,
            2 => Level::Info,
            3 => Level::Warn,
            4 => Level::Error,

            _ => panic!("invalid enum discriminant"),
          }
        }
      }

      #[allow(unused_unsafe, clippy::all)]
      #[allow(async_fn_in_trait)]
      pub fn write(level: Level,msg: &str,fields: &[Attr],) -> (){
        unsafe {
          let vec0 = msg;
          let ptr0 = vec0.as_ptr().cast::<u8>();
          let len0 = vec0.len();
          let vec4 = fields;
          let len4 = vec4.len();
          let layout4 = _rt::alloc::Layout::from_size_align(vec4.len() * (4*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>()).unwrap();
          let (result4, _cleanup4) = wit_bindgen::rt::Cleanup::new(layout4);for (i, e) in vec4.into_iter().enumerate() {
            let base = result4.add(i * (4*::core::mem::size_of::<*const u8>()));
            {
              let super::super::super::bex::plugin::common::Attr{ key:key1, value:value1, } = e;
              let vec2 = key1;
              let ptr2 = vec2.as_ptr().cast::<u8>();
              let len2 = vec2.len();
              *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len2;
              *base.add(0).cast::<*mut u8>() = ptr2.cast_mut();
              let vec3 = value1;
              let ptr3 = vec3.as_ptr().cast::<u8>();
              let len3 = vec3.len();
              *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len3;
              *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr3.cast_mut();
            }
          }

          #[cfg(target_arch = "wasm32")]
          #[link(wasm_import_module = "bex:plugin/log@1.0.0")]
          unsafe extern "C" {
            #[link_name = "write"]
            fn wit_import5(_: i32, _: *mut u8, _: usize, _: *mut u8, _: usize, );
          }

          #[cfg(not(target_arch = "wasm32"))]
          unsafe extern "C" fn wit_import5(_: i32, _: *mut u8, _: usize, _: *mut u8, _: usize, ) { unreachable!() }
          wit_import5(level.clone() as i32, ptr0.cast_mut(), len0, result4, len4);
        }
      }

    }


    #[allow(dead_code, async_fn_in_trait, unused_imports, clippy::all)]
    pub mod clock {
      #[used]
      #[doc(hidden)]
      static __FORCE_SECTION_REF: fn() =
      super::super::super::__link_custom_section_describing_imports;
      
      #[allow(unused_unsafe, clippy::all)]
      #[allow(async_fn_in_trait)]
      pub fn now_ms() -> u64{
        unsafe {

          #[cfg(target_arch = "wasm32")]
          #[link(wasm_import_module = "bex:plugin/clock@1.0.0")]
          unsafe extern "C" {
            #[link_name = "now-ms"]
            fn wit_import0() -> i64;
          }

          #[cfg(not(target_arch = "wasm32"))]
          unsafe extern "C" fn wit_import0() -> i64 { unreachable!() }
          let ret = wit_import0();
          ret as u64
        }
      }
      #[allow(unused_unsafe, clippy::all)]
      #[allow(async_fn_in_trait)]
      pub fn monotonic() -> u64{
        unsafe {

          #[cfg(target_arch = "wasm32")]
          #[link(wasm_import_module = "bex:plugin/clock@1.0.0")]
          unsafe extern "C" {
            #[link_name = "monotonic"]
            fn wit_import0() -> i64;
          }

          #[cfg(not(target_arch = "wasm32"))]
          unsafe extern "C" fn wit_import0() -> i64 { unreachable!() }
          let ret = wit_import0();
          ret as u64
        }
      }

    }


    #[allow(dead_code, async_fn_in_trait, unused_imports, clippy::all)]
    pub mod rng {
      #[used]
      #[doc(hidden)]
      static __FORCE_SECTION_REF: fn() =
      super::super::super::__link_custom_section_describing_imports;
      
      use super::super::super::_rt;
      #[allow(unused_unsafe, clippy::all)]
      #[allow(async_fn_in_trait)]
      pub fn bytes(len: u32,) -> _rt::Vec::<u8>{
        unsafe {

          #[cfg_attr(target_pointer_width="64", repr(align(8)))]
          #[cfg_attr(target_pointer_width="32", repr(align(4)))]
          struct RetArea([::core::mem::MaybeUninit::<u8>; 2*::core::mem::size_of::<*const u8>()]);
          let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 2*::core::mem::size_of::<*const u8>()]);
          let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
          #[cfg(target_arch = "wasm32")]
          #[link(wasm_import_module = "bex:plugin/rng@1.0.0")]
          unsafe extern "C" {
            #[link_name = "bytes"]
            fn wit_import1(_: i32, _: *mut u8, );
          }

          #[cfg(not(target_arch = "wasm32"))]
          unsafe extern "C" fn wit_import1(_: i32, _: *mut u8, ) { unreachable!() }
          wit_import1(_rt::as_i32(&len), ptr0);
          let l2 = *ptr0.add(0).cast::<*mut u8>();
          let l3 = *ptr0.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
          let len4 = l3;
          let result5 = <_ as From<_rt::Vec<_>>>::from(_rt::Vec::from_raw_parts(l2.cast(), len4, len4));
          result5
        }
      }

    }

  }
}
#[allow(dead_code, clippy::all)]
pub mod exports {

  #[allow(dead_code, async_fn_in_trait, unused_imports, clippy::all)]
  pub mod api {
    #[used]
    #[doc(hidden)]
    static __FORCE_SECTION_REF: fn() =
    super::super::__link_custom_section_describing_imports;
    
    use super::super::_rt;
    pub type RequestContext = super::super::bex::plugin::common::RequestContext;
    pub type PageCursor = super::super::bex::plugin::common::PageCursor;
    pub type PagedResult = super::super::bex::plugin::common::PagedResult;
    pub type SearchFilters = super::super::bex::plugin::common::SearchFilters;
    pub type HomeSection = super::super::bex::plugin::common::HomeSection;
    pub type MediaInfo = super::super::bex::plugin::common::MediaInfo;
    pub type Server = super::super::bex::plugin::common::Server;
    pub type StreamSource = super::super::bex::plugin::common::StreamSource;
    pub type SubtitleQuery = super::super::bex::plugin::common::SubtitleQuery;
    pub type SubtitleEntry = super::super::bex::plugin::common::SubtitleEntry;
    pub type SubtitleFile = super::super::bex::plugin::common::SubtitleFile;
    pub type ArticleSection = super::super::bex::plugin::common::ArticleSection;
    pub type Article = super::super::bex::plugin::common::Article;
    pub type PluginError = super::super::bex::plugin::common::PluginError;
    #[doc(hidden)]
    #[allow(non_snake_case, unused_unsafe)]
    pub unsafe fn _export_get_home_cabi<T_: Guest>(arg0: *mut u8,arg1: usize,arg2: i32,arg3: *mut u8,arg4: usize,arg5: i32,arg6: *mut u8,arg7: usize,arg8: i32,arg9: *mut u8,arg10: usize,) -> *mut u8 { unsafe {#[cfg(target_arch="wasm32")]
    _rt::run_ctors_once();let result7 = {
      let len0 = arg1;
      let bytes0 = _rt::Vec::from_raw_parts(arg0.cast(), len0, len0);
      let base6 = arg9;
      let len6 = arg10;
      let mut result6 = _rt::Vec::with_capacity(len6);
      for i in 0..len6 {
        let base = base6.add(i * (2*::core::mem::size_of::<*const u8>()));
        let e6 = {
          let l3 = *base.add(0).cast::<*mut u8>();
          let l4 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
          let len5 = l4;
          let bytes5 = _rt::Vec::from_raw_parts(l3.cast(), len5, len5);

          _rt::string_lift(bytes5)
        };
        result6.push(e6);
      }
      _rt::cabi_dealloc(base6, len6 * (2*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
      T_::get_home(super::super::bex::plugin::common::RequestContext{
        request_id: _rt::string_lift(bytes0),
        locale: match arg2 {
          0 => None,
          1 => {
            let e = {
              let len1 = arg4;
              let bytes1 = _rt::Vec::from_raw_parts(arg3.cast(), len1, len1);

              _rt::string_lift(bytes1)
            };
            Some(e)
          }
          _ => _rt::invalid_enum_discriminant(),
        },
        region: match arg5 {
          0 => None,
          1 => {
            let e = {
              let len2 = arg7;
              let bytes2 = _rt::Vec::from_raw_parts(arg6.cast(), len2, len2);

              _rt::string_lift(bytes2)
            };
            Some(e)
          }
          _ => _rt::invalid_enum_discriminant(),
        },
        safe_mode: _rt::bool_lift(arg8 as u8),
        hints: result6,
      })
    };
    let ptr8 = (&raw mut _RET_AREA.0).cast::<u8>();
    match result7 {
      Ok(e) => { {
        *ptr8.add(0).cast::<u8>() = (0i32) as u8;
        let vec61 = e;
        let len61 = vec61.len();
        let layout61 = _rt::alloc::Layout::from_size_align(vec61.len() * (17*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>()).unwrap();
        let (result61, _cleanup61) = wit_bindgen::rt::Cleanup::new(layout61);if let Some(cleanup) = _cleanup61 { cleanup.forget(); }
        for (i, e) in vec61.into_iter().enumerate() {
          let base = result61.add(i * (17*::core::mem::size_of::<*const u8>()));
          {
            let super::super::bex::plugin::common::HomeSection{ id:id9, title:title9, subtitle:subtitle9, items:items9, next_page:next_page9, layout:layout9, show_rank:show_rank9, categories:categories9, extra:extra9, } = e;
            let vec10 = (id9.into_bytes()).into_boxed_slice();
            let ptr10 = vec10.as_ptr().cast::<u8>();
            let len10 = vec10.len();
            ::core::mem::forget(vec10);
            *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len10;
            *base.add(0).cast::<*mut u8>() = ptr10.cast_mut();
            let vec11 = (title9.into_bytes()).into_boxed_slice();
            let ptr11 = vec11.as_ptr().cast::<u8>();
            let len11 = vec11.len();
            ::core::mem::forget(vec11);
            *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len11;
            *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr11.cast_mut();
            match subtitle9 {
              Some(e) => {
                *base.add(4*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                let vec12 = (e.into_bytes()).into_boxed_slice();
                let ptr12 = vec12.as_ptr().cast::<u8>();
                let len12 = vec12.len();
                ::core::mem::forget(vec12);
                *base.add(6*::core::mem::size_of::<*const u8>()).cast::<usize>() = len12;
                *base.add(5*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr12.cast_mut();
              },
              None => {
                {
                  *base.add(4*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                }
              },
            };let vec47 = items9;
            let len47 = vec47.len();
            let layout47 = _rt::alloc::Layout::from_size_align(vec47.len() * (88+63*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>()).unwrap();
            let (result47, _cleanup47) = wit_bindgen::rt::Cleanup::new(layout47);if let Some(cleanup) = _cleanup47 { cleanup.forget(); }
            for (i, e) in vec47.into_iter().enumerate() {
              let base = result47.add(i * (88+63*::core::mem::size_of::<*const u8>()));
              {
                let super::super::bex::plugin::common::MediaCard{ id:id13, title:title13, kind:kind13, images:images13, original_title:original_title13, tagline:tagline13, year:year13, score:score13, genres:genres13, status:status13, content_rating:content_rating13, url:url13, ids:ids13, extra:extra13, } = e;
                let vec14 = (id13.into_bytes()).into_boxed_slice();
                let ptr14 = vec14.as_ptr().cast::<u8>();
                let len14 = vec14.len();
                ::core::mem::forget(vec14);
                *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len14;
                *base.add(0).cast::<*mut u8>() = ptr14.cast_mut();
                let vec15 = (title13.into_bytes()).into_boxed_slice();
                let ptr15 = vec15.as_ptr().cast::<u8>();
                let len15 = vec15.len();
                ::core::mem::forget(vec15);
                *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len15;
                *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr15.cast_mut();
                match kind13 {
                  Some(e) => {
                    *base.add(4*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                    *base.add(1+4*::core::mem::size_of::<*const u8>()).cast::<u8>() = (e.clone() as i32) as u8;
                  },
                  None => {
                    {
                      *base.add(4*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                    }
                  },
                };match images13 {
                  Some(e) => {
                    *base.add(5*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                    let super::super::bex::plugin::common::ImageSet{ low:low16, medium:medium16, high:high16, backdrop:backdrop16, logo:logo16, } = e;
                    match low16 {
                      Some(e) => {
                        *base.add(6*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                        let super::super::bex::plugin::common::Image{ url:url17, layout:layout17, width:width17, height:height17, blurhash:blurhash17, } = e;
                        let vec18 = (url17.into_bytes()).into_boxed_slice();
                        let ptr18 = vec18.as_ptr().cast::<u8>();
                        let len18 = vec18.len();
                        ::core::mem::forget(vec18);
                        *base.add(8*::core::mem::size_of::<*const u8>()).cast::<usize>() = len18;
                        *base.add(7*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr18.cast_mut();
                        *base.add(9*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout17.clone() as i32) as u8;
                        match width17 {
                          Some(e) => {
                            *base.add(4+9*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                            *base.add(8+9*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                          },
                          None => {
                            {
                              *base.add(4+9*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                            }
                          },
                        };match height17 {
                          Some(e) => {
                            *base.add(12+9*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                            *base.add(16+9*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                          },
                          None => {
                            {
                              *base.add(12+9*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                            }
                          },
                        };match blurhash17 {
                          Some(e) => {
                            *base.add(16+10*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                            let vec19 = (e.into_bytes()).into_boxed_slice();
                            let ptr19 = vec19.as_ptr().cast::<u8>();
                            let len19 = vec19.len();
                            ::core::mem::forget(vec19);
                            *base.add(16+12*::core::mem::size_of::<*const u8>()).cast::<usize>() = len19;
                            *base.add(16+11*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr19.cast_mut();
                          },
                          None => {
                            {
                              *base.add(16+10*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                            }
                          },
                        };},
                        None => {
                          {
                            *base.add(6*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                          }
                        },
                      };match medium16 {
                        Some(e) => {
                          *base.add(16+13*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                          let super::super::bex::plugin::common::Image{ url:url20, layout:layout20, width:width20, height:height20, blurhash:blurhash20, } = e;
                          let vec21 = (url20.into_bytes()).into_boxed_slice();
                          let ptr21 = vec21.as_ptr().cast::<u8>();
                          let len21 = vec21.len();
                          ::core::mem::forget(vec21);
                          *base.add(16+15*::core::mem::size_of::<*const u8>()).cast::<usize>() = len21;
                          *base.add(16+14*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr21.cast_mut();
                          *base.add(16+16*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout20.clone() as i32) as u8;
                          match width20 {
                            Some(e) => {
                              *base.add(20+16*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                              *base.add(24+16*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                            },
                            None => {
                              {
                                *base.add(20+16*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                              }
                            },
                          };match height20 {
                            Some(e) => {
                              *base.add(28+16*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                              *base.add(32+16*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                            },
                            None => {
                              {
                                *base.add(28+16*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                              }
                            },
                          };match blurhash20 {
                            Some(e) => {
                              *base.add(32+17*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                              let vec22 = (e.into_bytes()).into_boxed_slice();
                              let ptr22 = vec22.as_ptr().cast::<u8>();
                              let len22 = vec22.len();
                              ::core::mem::forget(vec22);
                              *base.add(32+19*::core::mem::size_of::<*const u8>()).cast::<usize>() = len22;
                              *base.add(32+18*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr22.cast_mut();
                            },
                            None => {
                              {
                                *base.add(32+17*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                              }
                            },
                          };},
                          None => {
                            {
                              *base.add(16+13*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                            }
                          },
                        };match high16 {
                          Some(e) => {
                            *base.add(32+20*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                            let super::super::bex::plugin::common::Image{ url:url23, layout:layout23, width:width23, height:height23, blurhash:blurhash23, } = e;
                            let vec24 = (url23.into_bytes()).into_boxed_slice();
                            let ptr24 = vec24.as_ptr().cast::<u8>();
                            let len24 = vec24.len();
                            ::core::mem::forget(vec24);
                            *base.add(32+22*::core::mem::size_of::<*const u8>()).cast::<usize>() = len24;
                            *base.add(32+21*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr24.cast_mut();
                            *base.add(32+23*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout23.clone() as i32) as u8;
                            match width23 {
                              Some(e) => {
                                *base.add(36+23*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                *base.add(40+23*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                              },
                              None => {
                                {
                                  *base.add(36+23*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                }
                              },
                            };match height23 {
                              Some(e) => {
                                *base.add(44+23*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                *base.add(48+23*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                              },
                              None => {
                                {
                                  *base.add(44+23*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                }
                              },
                            };match blurhash23 {
                              Some(e) => {
                                *base.add(48+24*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                let vec25 = (e.into_bytes()).into_boxed_slice();
                                let ptr25 = vec25.as_ptr().cast::<u8>();
                                let len25 = vec25.len();
                                ::core::mem::forget(vec25);
                                *base.add(48+26*::core::mem::size_of::<*const u8>()).cast::<usize>() = len25;
                                *base.add(48+25*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr25.cast_mut();
                              },
                              None => {
                                {
                                  *base.add(48+24*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                }
                              },
                            };},
                            None => {
                              {
                                *base.add(32+20*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                              }
                            },
                          };match backdrop16 {
                            Some(e) => {
                              *base.add(48+27*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                              let super::super::bex::plugin::common::Image{ url:url26, layout:layout26, width:width26, height:height26, blurhash:blurhash26, } = e;
                              let vec27 = (url26.into_bytes()).into_boxed_slice();
                              let ptr27 = vec27.as_ptr().cast::<u8>();
                              let len27 = vec27.len();
                              ::core::mem::forget(vec27);
                              *base.add(48+29*::core::mem::size_of::<*const u8>()).cast::<usize>() = len27;
                              *base.add(48+28*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr27.cast_mut();
                              *base.add(48+30*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout26.clone() as i32) as u8;
                              match width26 {
                                Some(e) => {
                                  *base.add(52+30*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                  *base.add(56+30*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                },
                                None => {
                                  {
                                    *base.add(52+30*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                  }
                                },
                              };match height26 {
                                Some(e) => {
                                  *base.add(60+30*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                  *base.add(64+30*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                },
                                None => {
                                  {
                                    *base.add(60+30*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                  }
                                },
                              };match blurhash26 {
                                Some(e) => {
                                  *base.add(64+31*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                  let vec28 = (e.into_bytes()).into_boxed_slice();
                                  let ptr28 = vec28.as_ptr().cast::<u8>();
                                  let len28 = vec28.len();
                                  ::core::mem::forget(vec28);
                                  *base.add(64+33*::core::mem::size_of::<*const u8>()).cast::<usize>() = len28;
                                  *base.add(64+32*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr28.cast_mut();
                                },
                                None => {
                                  {
                                    *base.add(64+31*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                  }
                                },
                              };},
                              None => {
                                {
                                  *base.add(48+27*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                }
                              },
                            };match logo16 {
                              Some(e) => {
                                *base.add(64+34*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                let super::super::bex::plugin::common::Image{ url:url29, layout:layout29, width:width29, height:height29, blurhash:blurhash29, } = e;
                                let vec30 = (url29.into_bytes()).into_boxed_slice();
                                let ptr30 = vec30.as_ptr().cast::<u8>();
                                let len30 = vec30.len();
                                ::core::mem::forget(vec30);
                                *base.add(64+36*::core::mem::size_of::<*const u8>()).cast::<usize>() = len30;
                                *base.add(64+35*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr30.cast_mut();
                                *base.add(64+37*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout29.clone() as i32) as u8;
                                match width29 {
                                  Some(e) => {
                                    *base.add(68+37*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                    *base.add(72+37*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                  },
                                  None => {
                                    {
                                      *base.add(68+37*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                    }
                                  },
                                };match height29 {
                                  Some(e) => {
                                    *base.add(76+37*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                    *base.add(80+37*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                  },
                                  None => {
                                    {
                                      *base.add(76+37*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                    }
                                  },
                                };match blurhash29 {
                                  Some(e) => {
                                    *base.add(80+38*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                    let vec31 = (e.into_bytes()).into_boxed_slice();
                                    let ptr31 = vec31.as_ptr().cast::<u8>();
                                    let len31 = vec31.len();
                                    ::core::mem::forget(vec31);
                                    *base.add(80+40*::core::mem::size_of::<*const u8>()).cast::<usize>() = len31;
                                    *base.add(80+39*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr31.cast_mut();
                                  },
                                  None => {
                                    {
                                      *base.add(80+38*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                    }
                                  },
                                };},
                                None => {
                                  {
                                    *base.add(64+34*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                  }
                                },
                              };},
                              None => {
                                {
                                  *base.add(5*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                }
                              },
                            };match original_title13 {
                              Some(e) => {
                                *base.add(80+41*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                let vec32 = (e.into_bytes()).into_boxed_slice();
                                let ptr32 = vec32.as_ptr().cast::<u8>();
                                let len32 = vec32.len();
                                ::core::mem::forget(vec32);
                                *base.add(80+43*::core::mem::size_of::<*const u8>()).cast::<usize>() = len32;
                                *base.add(80+42*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr32.cast_mut();
                              },
                              None => {
                                {
                                  *base.add(80+41*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                }
                              },
                            };match tagline13 {
                              Some(e) => {
                                *base.add(80+44*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                let vec33 = (e.into_bytes()).into_boxed_slice();
                                let ptr33 = vec33.as_ptr().cast::<u8>();
                                let len33 = vec33.len();
                                ::core::mem::forget(vec33);
                                *base.add(80+46*::core::mem::size_of::<*const u8>()).cast::<usize>() = len33;
                                *base.add(80+45*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr33.cast_mut();
                              },
                              None => {
                                {
                                  *base.add(80+44*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                }
                              },
                            };match year13 {
                              Some(e) => {
                                *base.add(80+47*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                let vec34 = (e.into_bytes()).into_boxed_slice();
                                let ptr34 = vec34.as_ptr().cast::<u8>();
                                let len34 = vec34.len();
                                ::core::mem::forget(vec34);
                                *base.add(80+49*::core::mem::size_of::<*const u8>()).cast::<usize>() = len34;
                                *base.add(80+48*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr34.cast_mut();
                              },
                              None => {
                                {
                                  *base.add(80+47*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                }
                              },
                            };match score13 {
                              Some(e) => {
                                *base.add(80+50*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                *base.add(84+50*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                              },
                              None => {
                                {
                                  *base.add(80+50*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                }
                              },
                            };let vec36 = genres13;
                            let len36 = vec36.len();
                            let layout36 = _rt::alloc::Layout::from_size_align(vec36.len() * (2*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>()).unwrap();
                            let (result36, _cleanup36) = wit_bindgen::rt::Cleanup::new(layout36);if let Some(cleanup) = _cleanup36 { cleanup.forget(); }
                            for (i, e) in vec36.into_iter().enumerate() {
                              let base = result36.add(i * (2*::core::mem::size_of::<*const u8>()));
                              {
                                let vec35 = (e.into_bytes()).into_boxed_slice();
                                let ptr35 = vec35.as_ptr().cast::<u8>();
                                let len35 = vec35.len();
                                ::core::mem::forget(vec35);
                                *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len35;
                                *base.add(0).cast::<*mut u8>() = ptr35.cast_mut();
                              }
                            }
                            *base.add(88+51*::core::mem::size_of::<*const u8>()).cast::<usize>() = len36;
                            *base.add(88+50*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result36;
                            match status13 {
                              Some(e) => {
                                *base.add(88+52*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                *base.add(89+52*::core::mem::size_of::<*const u8>()).cast::<u8>() = (e.clone() as i32) as u8;
                              },
                              None => {
                                {
                                  *base.add(88+52*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                }
                              },
                            };match content_rating13 {
                              Some(e) => {
                                *base.add(88+53*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                let vec37 = (e.into_bytes()).into_boxed_slice();
                                let ptr37 = vec37.as_ptr().cast::<u8>();
                                let len37 = vec37.len();
                                ::core::mem::forget(vec37);
                                *base.add(88+55*::core::mem::size_of::<*const u8>()).cast::<usize>() = len37;
                                *base.add(88+54*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr37.cast_mut();
                              },
                              None => {
                                {
                                  *base.add(88+53*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                }
                              },
                            };match url13 {
                              Some(e) => {
                                *base.add(88+56*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                let vec38 = (e.into_bytes()).into_boxed_slice();
                                let ptr38 = vec38.as_ptr().cast::<u8>();
                                let len38 = vec38.len();
                                ::core::mem::forget(vec38);
                                *base.add(88+58*::core::mem::size_of::<*const u8>()).cast::<usize>() = len38;
                                *base.add(88+57*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr38.cast_mut();
                              },
                              None => {
                                {
                                  *base.add(88+56*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                }
                              },
                            };let vec42 = ids13;
                            let len42 = vec42.len();
                            let layout42 = _rt::alloc::Layout::from_size_align(vec42.len() * (4*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>()).unwrap();
                            let (result42, _cleanup42) = wit_bindgen::rt::Cleanup::new(layout42);if let Some(cleanup) = _cleanup42 { cleanup.forget(); }
                            for (i, e) in vec42.into_iter().enumerate() {
                              let base = result42.add(i * (4*::core::mem::size_of::<*const u8>()));
                              {
                                let super::super::bex::plugin::common::LinkedId{ source:source39, id:id39, } = e;
                                let vec40 = (source39.into_bytes()).into_boxed_slice();
                                let ptr40 = vec40.as_ptr().cast::<u8>();
                                let len40 = vec40.len();
                                ::core::mem::forget(vec40);
                                *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len40;
                                *base.add(0).cast::<*mut u8>() = ptr40.cast_mut();
                                let vec41 = (id39.into_bytes()).into_boxed_slice();
                                let ptr41 = vec41.as_ptr().cast::<u8>();
                                let len41 = vec41.len();
                                ::core::mem::forget(vec41);
                                *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len41;
                                *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr41.cast_mut();
                              }
                            }
                            *base.add(88+60*::core::mem::size_of::<*const u8>()).cast::<usize>() = len42;
                            *base.add(88+59*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result42;
                            let vec46 = extra13;
                            let len46 = vec46.len();
                            let layout46 = _rt::alloc::Layout::from_size_align(vec46.len() * (4*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>()).unwrap();
                            let (result46, _cleanup46) = wit_bindgen::rt::Cleanup::new(layout46);if let Some(cleanup) = _cleanup46 { cleanup.forget(); }
                            for (i, e) in vec46.into_iter().enumerate() {
                              let base = result46.add(i * (4*::core::mem::size_of::<*const u8>()));
                              {
                                let super::super::bex::plugin::common::Attr{ key:key43, value:value43, } = e;
                                let vec44 = (key43.into_bytes()).into_boxed_slice();
                                let ptr44 = vec44.as_ptr().cast::<u8>();
                                let len44 = vec44.len();
                                ::core::mem::forget(vec44);
                                *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len44;
                                *base.add(0).cast::<*mut u8>() = ptr44.cast_mut();
                                let vec45 = (value43.into_bytes()).into_boxed_slice();
                                let ptr45 = vec45.as_ptr().cast::<u8>();
                                let len45 = vec45.len();
                                ::core::mem::forget(vec45);
                                *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len45;
                                *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr45.cast_mut();
                              }
                            }
                            *base.add(88+62*::core::mem::size_of::<*const u8>()).cast::<usize>() = len46;
                            *base.add(88+61*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result46;
                          }
                        }
                        *base.add(8*::core::mem::size_of::<*const u8>()).cast::<usize>() = len47;
                        *base.add(7*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result47;
                        match next_page9 {
                          Some(e) => {
                            *base.add(9*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                            let vec48 = (e.into_bytes()).into_boxed_slice();
                            let ptr48 = vec48.as_ptr().cast::<u8>();
                            let len48 = vec48.len();
                            ::core::mem::forget(vec48);
                            *base.add(11*::core::mem::size_of::<*const u8>()).cast::<usize>() = len48;
                            *base.add(10*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr48.cast_mut();
                          },
                          None => {
                            {
                              *base.add(9*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                            }
                          },
                        };*base.add(12*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout9.clone() as i32) as u8;
                        *base.add(1+12*::core::mem::size_of::<*const u8>()).cast::<u8>() = (match show_rank9 { true => 1, false => 0 }) as u8;
                        let vec56 = categories9;
                        let len56 = vec56.len();
                        let layout56 = _rt::alloc::Layout::from_size_align(vec56.len() * (16+14*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>()).unwrap();
                        let (result56, _cleanup56) = wit_bindgen::rt::Cleanup::new(layout56);if let Some(cleanup) = _cleanup56 { cleanup.forget(); }
                        for (i, e) in vec56.into_iter().enumerate() {
                          let base = result56.add(i * (16+14*::core::mem::size_of::<*const u8>()));
                          {
                            let super::super::bex::plugin::common::CategoryLink{ id:id49, title:title49, subtitle:subtitle49, image:image49, } = e;
                            let vec50 = (id49.into_bytes()).into_boxed_slice();
                            let ptr50 = vec50.as_ptr().cast::<u8>();
                            let len50 = vec50.len();
                            ::core::mem::forget(vec50);
                            *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len50;
                            *base.add(0).cast::<*mut u8>() = ptr50.cast_mut();
                            let vec51 = (title49.into_bytes()).into_boxed_slice();
                            let ptr51 = vec51.as_ptr().cast::<u8>();
                            let len51 = vec51.len();
                            ::core::mem::forget(vec51);
                            *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len51;
                            *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr51.cast_mut();
                            match subtitle49 {
                              Some(e) => {
                                *base.add(4*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                let vec52 = (e.into_bytes()).into_boxed_slice();
                                let ptr52 = vec52.as_ptr().cast::<u8>();
                                let len52 = vec52.len();
                                ::core::mem::forget(vec52);
                                *base.add(6*::core::mem::size_of::<*const u8>()).cast::<usize>() = len52;
                                *base.add(5*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr52.cast_mut();
                              },
                              None => {
                                {
                                  *base.add(4*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                }
                              },
                            };match image49 {
                              Some(e) => {
                                *base.add(7*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                let super::super::bex::plugin::common::Image{ url:url53, layout:layout53, width:width53, height:height53, blurhash:blurhash53, } = e;
                                let vec54 = (url53.into_bytes()).into_boxed_slice();
                                let ptr54 = vec54.as_ptr().cast::<u8>();
                                let len54 = vec54.len();
                                ::core::mem::forget(vec54);
                                *base.add(9*::core::mem::size_of::<*const u8>()).cast::<usize>() = len54;
                                *base.add(8*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr54.cast_mut();
                                *base.add(10*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout53.clone() as i32) as u8;
                                match width53 {
                                  Some(e) => {
                                    *base.add(4+10*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                    *base.add(8+10*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                  },
                                  None => {
                                    {
                                      *base.add(4+10*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                    }
                                  },
                                };match height53 {
                                  Some(e) => {
                                    *base.add(12+10*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                    *base.add(16+10*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                  },
                                  None => {
                                    {
                                      *base.add(12+10*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                    }
                                  },
                                };match blurhash53 {
                                  Some(e) => {
                                    *base.add(16+11*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                    let vec55 = (e.into_bytes()).into_boxed_slice();
                                    let ptr55 = vec55.as_ptr().cast::<u8>();
                                    let len55 = vec55.len();
                                    ::core::mem::forget(vec55);
                                    *base.add(16+13*::core::mem::size_of::<*const u8>()).cast::<usize>() = len55;
                                    *base.add(16+12*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr55.cast_mut();
                                  },
                                  None => {
                                    {
                                      *base.add(16+11*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                    }
                                  },
                                };},
                                None => {
                                  {
                                    *base.add(7*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                  }
                                },
                              };}
                            }
                            *base.add(14*::core::mem::size_of::<*const u8>()).cast::<usize>() = len56;
                            *base.add(13*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result56;
                            let vec60 = extra9;
                            let len60 = vec60.len();
                            let layout60 = _rt::alloc::Layout::from_size_align(vec60.len() * (4*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>()).unwrap();
                            let (result60, _cleanup60) = wit_bindgen::rt::Cleanup::new(layout60);if let Some(cleanup) = _cleanup60 { cleanup.forget(); }
                            for (i, e) in vec60.into_iter().enumerate() {
                              let base = result60.add(i * (4*::core::mem::size_of::<*const u8>()));
                              {
                                let super::super::bex::plugin::common::Attr{ key:key57, value:value57, } = e;
                                let vec58 = (key57.into_bytes()).into_boxed_slice();
                                let ptr58 = vec58.as_ptr().cast::<u8>();
                                let len58 = vec58.len();
                                ::core::mem::forget(vec58);
                                *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len58;
                                *base.add(0).cast::<*mut u8>() = ptr58.cast_mut();
                                let vec59 = (value57.into_bytes()).into_boxed_slice();
                                let ptr59 = vec59.as_ptr().cast::<u8>();
                                let len59 = vec59.len();
                                ::core::mem::forget(vec59);
                                *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len59;
                                *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr59.cast_mut();
                              }
                            }
                            *base.add(16*::core::mem::size_of::<*const u8>()).cast::<usize>() = len60;
                            *base.add(15*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result60;
                          }
                        }
                        *ptr8.add(2*::core::mem::size_of::<*const u8>()).cast::<usize>() = len61;
                        *ptr8.add(::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result61;
                      } },
                      Err(e) => { {
                        *ptr8.add(0).cast::<u8>() = (1i32) as u8;
                        use super::super::bex::plugin::common::PluginError as V66;
                        match e {
                          V66::Network(e) => {
                            *ptr8.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                            let vec62 = (e.into_bytes()).into_boxed_slice();
                            let ptr62 = vec62.as_ptr().cast::<u8>();
                            let len62 = vec62.len();
                            ::core::mem::forget(vec62);
                            *ptr8.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len62;
                            *ptr8.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr62.cast_mut();
                          },
                          V66::Parse(e) => {
                            *ptr8.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                            let vec63 = (e.into_bytes()).into_boxed_slice();
                            let ptr63 = vec63.as_ptr().cast::<u8>();
                            let len63 = vec63.len();
                            ::core::mem::forget(vec63);
                            *ptr8.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len63;
                            *ptr8.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr63.cast_mut();
                          },
                          V66::NotFound=> {
                            {
                              *ptr8.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (2i32) as u8;
                            }
                          }
                          V66::Unauthorized=> {
                            {
                              *ptr8.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (3i32) as u8;
                            }
                          }
                          V66::Forbidden=> {
                            {
                              *ptr8.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (4i32) as u8;
                            }
                          }
                          V66::RateLimited(e) => {
                            *ptr8.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (5i32) as u8;
                            match e {
                              Some(e) => {
                                *ptr8.add(2*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                *ptr8.add(4+2*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                              },
                              None => {
                                {
                                  *ptr8.add(2*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                }
                              },
                            };},
                            V66::Timeout=> {
                              {
                                *ptr8.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (6i32) as u8;
                              }
                            }
                            V66::Cancelled=> {
                              {
                                *ptr8.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (7i32) as u8;
                              }
                            }
                            V66::Unsupported=> {
                              {
                                *ptr8.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (8i32) as u8;
                              }
                            }
                            V66::InvalidInput(e) => {
                              *ptr8.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (9i32) as u8;
                              let vec64 = (e.into_bytes()).into_boxed_slice();
                              let ptr64 = vec64.as_ptr().cast::<u8>();
                              let len64 = vec64.len();
                              ::core::mem::forget(vec64);
                              *ptr8.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len64;
                              *ptr8.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr64.cast_mut();
                            },
                            V66::Internal(e) => {
                              *ptr8.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (10i32) as u8;
                              let vec65 = (e.into_bytes()).into_boxed_slice();
                              let ptr65 = vec65.as_ptr().cast::<u8>();
                              let len65 = vec65.len();
                              ::core::mem::forget(vec65);
                              *ptr8.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len65;
                              *ptr8.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr65.cast_mut();
                            },
                          }
                        } },
                      };ptr8
                    } }
                    #[doc(hidden)]
                    #[allow(non_snake_case)]
                    pub unsafe fn __post_return_get_home<T_: Guest>(arg0: *mut u8,) { unsafe {
                      let l0 = i32::from(*arg0.add(0).cast::<u8>());
                      match l0 {
                        0 => {
                          let l1 = *arg0.add(::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                          let l2 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<usize>();
                          let base108 = l1;
                          let len108 = l2;
                          for i in 0..len108 {
                            let base = base108.add(i * (17*::core::mem::size_of::<*const u8>()));
                            {
                              let l3 = *base.add(0).cast::<*mut u8>();
                              let l4 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                              _rt::cabi_dealloc(l3, l4, 1);
                              let l5 = *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                              let l6 = *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                              _rt::cabi_dealloc(l5, l6, 1);
                              let l7 = i32::from(*base.add(4*::core::mem::size_of::<*const u8>()).cast::<u8>());
                              match l7 {
                                0 => (),
                                _ => {
                                  let l8 = *base.add(5*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                  let l9 = *base.add(6*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                  _rt::cabi_dealloc(l8, l9, 1);
                                },
                              }
                              let l10 = *base.add(7*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                              let l11 = *base.add(8*::core::mem::size_of::<*const u8>()).cast::<usize>();
                              let base81 = l10;
                              let len81 = l11;
                              for i in 0..len81 {
                                let base = base81.add(i * (88+63*::core::mem::size_of::<*const u8>()));
                                {
                                  let l12 = *base.add(0).cast::<*mut u8>();
                                  let l13 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                  _rt::cabi_dealloc(l12, l13, 1);
                                  let l14 = *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                  let l15 = *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                  _rt::cabi_dealloc(l14, l15, 1);
                                  let l16 = i32::from(*base.add(5*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                  match l16 {
                                    0 => (),
                                    _ => {
                                      let l17 = i32::from(*base.add(6*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                      match l17 {
                                        0 => (),
                                        _ => {
                                          let l18 = *base.add(7*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                          let l19 = *base.add(8*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                          _rt::cabi_dealloc(l18, l19, 1);
                                          let l20 = i32::from(*base.add(16+10*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                          match l20 {
                                            0 => (),
                                            _ => {
                                              let l21 = *base.add(16+11*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                              let l22 = *base.add(16+12*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                              _rt::cabi_dealloc(l21, l22, 1);
                                            },
                                          }
                                        },
                                      }
                                      let l23 = i32::from(*base.add(16+13*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                      match l23 {
                                        0 => (),
                                        _ => {
                                          let l24 = *base.add(16+14*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                          let l25 = *base.add(16+15*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                          _rt::cabi_dealloc(l24, l25, 1);
                                          let l26 = i32::from(*base.add(32+17*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                          match l26 {
                                            0 => (),
                                            _ => {
                                              let l27 = *base.add(32+18*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                              let l28 = *base.add(32+19*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                              _rt::cabi_dealloc(l27, l28, 1);
                                            },
                                          }
                                        },
                                      }
                                      let l29 = i32::from(*base.add(32+20*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                      match l29 {
                                        0 => (),
                                        _ => {
                                          let l30 = *base.add(32+21*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                          let l31 = *base.add(32+22*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                          _rt::cabi_dealloc(l30, l31, 1);
                                          let l32 = i32::from(*base.add(48+24*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                          match l32 {
                                            0 => (),
                                            _ => {
                                              let l33 = *base.add(48+25*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                              let l34 = *base.add(48+26*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                              _rt::cabi_dealloc(l33, l34, 1);
                                            },
                                          }
                                        },
                                      }
                                      let l35 = i32::from(*base.add(48+27*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                      match l35 {
                                        0 => (),
                                        _ => {
                                          let l36 = *base.add(48+28*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                          let l37 = *base.add(48+29*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                          _rt::cabi_dealloc(l36, l37, 1);
                                          let l38 = i32::from(*base.add(64+31*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                          match l38 {
                                            0 => (),
                                            _ => {
                                              let l39 = *base.add(64+32*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                              let l40 = *base.add(64+33*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                              _rt::cabi_dealloc(l39, l40, 1);
                                            },
                                          }
                                        },
                                      }
                                      let l41 = i32::from(*base.add(64+34*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                      match l41 {
                                        0 => (),
                                        _ => {
                                          let l42 = *base.add(64+35*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                          let l43 = *base.add(64+36*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                          _rt::cabi_dealloc(l42, l43, 1);
                                          let l44 = i32::from(*base.add(80+38*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                          match l44 {
                                            0 => (),
                                            _ => {
                                              let l45 = *base.add(80+39*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                              let l46 = *base.add(80+40*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                              _rt::cabi_dealloc(l45, l46, 1);
                                            },
                                          }
                                        },
                                      }
                                    },
                                  }
                                  let l47 = i32::from(*base.add(80+41*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                  match l47 {
                                    0 => (),
                                    _ => {
                                      let l48 = *base.add(80+42*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                      let l49 = *base.add(80+43*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                      _rt::cabi_dealloc(l48, l49, 1);
                                    },
                                  }
                                  let l50 = i32::from(*base.add(80+44*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                  match l50 {
                                    0 => (),
                                    _ => {
                                      let l51 = *base.add(80+45*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                      let l52 = *base.add(80+46*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                      _rt::cabi_dealloc(l51, l52, 1);
                                    },
                                  }
                                  let l53 = i32::from(*base.add(80+47*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                  match l53 {
                                    0 => (),
                                    _ => {
                                      let l54 = *base.add(80+48*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                      let l55 = *base.add(80+49*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                      _rt::cabi_dealloc(l54, l55, 1);
                                    },
                                  }
                                  let l56 = *base.add(88+50*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                  let l57 = *base.add(88+51*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                  let base60 = l56;
                                  let len60 = l57;
                                  for i in 0..len60 {
                                    let base = base60.add(i * (2*::core::mem::size_of::<*const u8>()));
                                    {
                                      let l58 = *base.add(0).cast::<*mut u8>();
                                      let l59 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                      _rt::cabi_dealloc(l58, l59, 1);
                                    }
                                  }
                                  _rt::cabi_dealloc(base60, len60 * (2*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                  let l61 = i32::from(*base.add(88+53*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                  match l61 {
                                    0 => (),
                                    _ => {
                                      let l62 = *base.add(88+54*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                      let l63 = *base.add(88+55*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                      _rt::cabi_dealloc(l62, l63, 1);
                                    },
                                  }
                                  let l64 = i32::from(*base.add(88+56*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                  match l64 {
                                    0 => (),
                                    _ => {
                                      let l65 = *base.add(88+57*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                      let l66 = *base.add(88+58*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                      _rt::cabi_dealloc(l65, l66, 1);
                                    },
                                  }
                                  let l67 = *base.add(88+59*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                  let l68 = *base.add(88+60*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                  let base73 = l67;
                                  let len73 = l68;
                                  for i in 0..len73 {
                                    let base = base73.add(i * (4*::core::mem::size_of::<*const u8>()));
                                    {
                                      let l69 = *base.add(0).cast::<*mut u8>();
                                      let l70 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                      _rt::cabi_dealloc(l69, l70, 1);
                                      let l71 = *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                      let l72 = *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                      _rt::cabi_dealloc(l71, l72, 1);
                                    }
                                  }
                                  _rt::cabi_dealloc(base73, len73 * (4*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                  let l74 = *base.add(88+61*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                  let l75 = *base.add(88+62*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                  let base80 = l74;
                                  let len80 = l75;
                                  for i in 0..len80 {
                                    let base = base80.add(i * (4*::core::mem::size_of::<*const u8>()));
                                    {
                                      let l76 = *base.add(0).cast::<*mut u8>();
                                      let l77 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                      _rt::cabi_dealloc(l76, l77, 1);
                                      let l78 = *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                      let l79 = *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                      _rt::cabi_dealloc(l78, l79, 1);
                                    }
                                  }
                                  _rt::cabi_dealloc(base80, len80 * (4*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                }
                              }
                              _rt::cabi_dealloc(base81, len81 * (88+63*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                              let l82 = i32::from(*base.add(9*::core::mem::size_of::<*const u8>()).cast::<u8>());
                              match l82 {
                                0 => (),
                                _ => {
                                  let l83 = *base.add(10*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                  let l84 = *base.add(11*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                  _rt::cabi_dealloc(l83, l84, 1);
                                },
                              }
                              let l85 = *base.add(13*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                              let l86 = *base.add(14*::core::mem::size_of::<*const u8>()).cast::<usize>();
                              let base100 = l85;
                              let len100 = l86;
                              for i in 0..len100 {
                                let base = base100.add(i * (16+14*::core::mem::size_of::<*const u8>()));
                                {
                                  let l87 = *base.add(0).cast::<*mut u8>();
                                  let l88 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                  _rt::cabi_dealloc(l87, l88, 1);
                                  let l89 = *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                  let l90 = *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                  _rt::cabi_dealloc(l89, l90, 1);
                                  let l91 = i32::from(*base.add(4*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                  match l91 {
                                    0 => (),
                                    _ => {
                                      let l92 = *base.add(5*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                      let l93 = *base.add(6*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                      _rt::cabi_dealloc(l92, l93, 1);
                                    },
                                  }
                                  let l94 = i32::from(*base.add(7*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                  match l94 {
                                    0 => (),
                                    _ => {
                                      let l95 = *base.add(8*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                      let l96 = *base.add(9*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                      _rt::cabi_dealloc(l95, l96, 1);
                                      let l97 = i32::from(*base.add(16+11*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                      match l97 {
                                        0 => (),
                                        _ => {
                                          let l98 = *base.add(16+12*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                          let l99 = *base.add(16+13*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                          _rt::cabi_dealloc(l98, l99, 1);
                                        },
                                      }
                                    },
                                  }
                                }
                              }
                              _rt::cabi_dealloc(base100, len100 * (16+14*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                              let l101 = *base.add(15*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                              let l102 = *base.add(16*::core::mem::size_of::<*const u8>()).cast::<usize>();
                              let base107 = l101;
                              let len107 = l102;
                              for i in 0..len107 {
                                let base = base107.add(i * (4*::core::mem::size_of::<*const u8>()));
                                {
                                  let l103 = *base.add(0).cast::<*mut u8>();
                                  let l104 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                  _rt::cabi_dealloc(l103, l104, 1);
                                  let l105 = *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                  let l106 = *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                  _rt::cabi_dealloc(l105, l106, 1);
                                }
                              }
                              _rt::cabi_dealloc(base107, len107 * (4*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                            }
                          }
                          _rt::cabi_dealloc(base108, len108 * (17*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                        },
                        _ => {
                          let l109 = i32::from(*arg0.add(::core::mem::size_of::<*const u8>()).cast::<u8>());
                          match l109 {
                            0 => {
                              let l110 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                              let l111 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                              _rt::cabi_dealloc(l110, l111, 1);
                            },
                            1 => {
                              let l112 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                              let l113 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                              _rt::cabi_dealloc(l112, l113, 1);
                            },
                            2 => (),
                            3 => (),
                            4 => (),
                            5 => (),
                            6 => (),
                            7 => (),
                            8 => (),
                            9 => {
                              let l114 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                              let l115 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                              _rt::cabi_dealloc(l114, l115, 1);
                            },
                            _ => {
                              let l116 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                              let l117 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                              _rt::cabi_dealloc(l116, l117, 1);
                            },
                          }
                        },
                      }
                    } }
                    #[doc(hidden)]
                    #[allow(non_snake_case, unused_unsafe)]
                    pub unsafe fn _export_get_category_cabi<T_: Guest>(arg0: *mut u8,) -> *mut u8 { unsafe {#[cfg(target_arch="wasm32")]
                    _rt::run_ctors_once();let result27 = {
                      let l0 = *arg0.add(0).cast::<*mut u8>();
                      let l1 = *arg0.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                      let len2 = l1;
                      let bytes2 = _rt::Vec::from_raw_parts(l0.cast(), len2, len2);
                      let l3 = i32::from(*arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<u8>());
                      let l7 = i32::from(*arg0.add(5*::core::mem::size_of::<*const u8>()).cast::<u8>());
                      let l11 = i32::from(*arg0.add(8*::core::mem::size_of::<*const u8>()).cast::<u8>());
                      let l12 = *arg0.add(9*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                      let l13 = *arg0.add(10*::core::mem::size_of::<*const u8>()).cast::<usize>();
                      let base17 = l12;
                      let len17 = l13;
                      let mut result17 = _rt::Vec::with_capacity(len17);
                      for i in 0..len17 {
                        let base = base17.add(i * (2*::core::mem::size_of::<*const u8>()));
                        let e17 = {
                          let l14 = *base.add(0).cast::<*mut u8>();
                          let l15 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                          let len16 = l15;
                          let bytes16 = _rt::Vec::from_raw_parts(l14.cast(), len16, len16);

                          _rt::string_lift(bytes16)
                        };
                        result17.push(e17);
                      }
                      _rt::cabi_dealloc(base17, len17 * (2*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                      let l18 = *arg0.add(11*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                      let l19 = *arg0.add(12*::core::mem::size_of::<*const u8>()).cast::<usize>();
                      let len20 = l19;
                      let bytes20 = _rt::Vec::from_raw_parts(l18.cast(), len20, len20);
                      let l21 = i32::from(*arg0.add(13*::core::mem::size_of::<*const u8>()).cast::<u8>());
                      let l25 = i32::from(*arg0.add(16*::core::mem::size_of::<*const u8>()).cast::<u8>());
                      T_::get_category(super::super::bex::plugin::common::RequestContext{
                        request_id: _rt::string_lift(bytes2),
                        locale: match l3 {
                          0 => None,
                          1 => {
                            let e = {
                              let l4 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                              let l5 = *arg0.add(4*::core::mem::size_of::<*const u8>()).cast::<usize>();
                              let len6 = l5;
                              let bytes6 = _rt::Vec::from_raw_parts(l4.cast(), len6, len6);

                              _rt::string_lift(bytes6)
                            };
                            Some(e)
                          }
                          _ => _rt::invalid_enum_discriminant(),
                        },
                        region: match l7 {
                          0 => None,
                          1 => {
                            let e = {
                              let l8 = *arg0.add(6*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                              let l9 = *arg0.add(7*::core::mem::size_of::<*const u8>()).cast::<usize>();
                              let len10 = l9;
                              let bytes10 = _rt::Vec::from_raw_parts(l8.cast(), len10, len10);

                              _rt::string_lift(bytes10)
                            };
                            Some(e)
                          }
                          _ => _rt::invalid_enum_discriminant(),
                        },
                        safe_mode: _rt::bool_lift(l11 as u8),
                        hints: result17,
                      }, _rt::string_lift(bytes20), super::super::bex::plugin::common::PageCursor{
                        token: match l21 {
                          0 => None,
                          1 => {
                            let e = {
                              let l22 = *arg0.add(14*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                              let l23 = *arg0.add(15*::core::mem::size_of::<*const u8>()).cast::<usize>();
                              let len24 = l23;
                              let bytes24 = _rt::Vec::from_raw_parts(l22.cast(), len24, len24);

                              _rt::string_lift(bytes24)
                            };
                            Some(e)
                          }
                          _ => _rt::invalid_enum_discriminant(),
                        },
                        limit: match l25 {
                          0 => None,
                          1 => {
                            let e = {
                              let l26 = *arg0.add(4+16*::core::mem::size_of::<*const u8>()).cast::<i32>();

                              l26 as u32
                            };
                            Some(e)
                          }
                          _ => _rt::invalid_enum_discriminant(),
                        },
                      })
                    };
                    _rt::cabi_dealloc(arg0, 8+16*::core::mem::size_of::<*const u8>(), ::core::mem::size_of::<*const u8>());
                    let ptr28 = (&raw mut _RET_AREA.0).cast::<u8>();
                    match result27 {
                      Ok(e) => { {
                        *ptr28.add(0).cast::<u8>() = (0i32) as u8;
                        let super::super::bex::plugin::common::PagedResult{ items:items29, categories:categories29, next_page:next_page29, } = e;
                        let vec64 = items29;
                        let len64 = vec64.len();
                        let layout64 = _rt::alloc::Layout::from_size_align(vec64.len() * (88+63*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>()).unwrap();
                        let (result64, _cleanup64) = wit_bindgen::rt::Cleanup::new(layout64);if let Some(cleanup) = _cleanup64 { cleanup.forget(); }
                        for (i, e) in vec64.into_iter().enumerate() {
                          let base = result64.add(i * (88+63*::core::mem::size_of::<*const u8>()));
                          {
                            let super::super::bex::plugin::common::MediaCard{ id:id30, title:title30, kind:kind30, images:images30, original_title:original_title30, tagline:tagline30, year:year30, score:score30, genres:genres30, status:status30, content_rating:content_rating30, url:url30, ids:ids30, extra:extra30, } = e;
                            let vec31 = (id30.into_bytes()).into_boxed_slice();
                            let ptr31 = vec31.as_ptr().cast::<u8>();
                            let len31 = vec31.len();
                            ::core::mem::forget(vec31);
                            *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len31;
                            *base.add(0).cast::<*mut u8>() = ptr31.cast_mut();
                            let vec32 = (title30.into_bytes()).into_boxed_slice();
                            let ptr32 = vec32.as_ptr().cast::<u8>();
                            let len32 = vec32.len();
                            ::core::mem::forget(vec32);
                            *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len32;
                            *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr32.cast_mut();
                            match kind30 {
                              Some(e) => {
                                *base.add(4*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                *base.add(1+4*::core::mem::size_of::<*const u8>()).cast::<u8>() = (e.clone() as i32) as u8;
                              },
                              None => {
                                {
                                  *base.add(4*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                }
                              },
                            };match images30 {
                              Some(e) => {
                                *base.add(5*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                let super::super::bex::plugin::common::ImageSet{ low:low33, medium:medium33, high:high33, backdrop:backdrop33, logo:logo33, } = e;
                                match low33 {
                                  Some(e) => {
                                    *base.add(6*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                    let super::super::bex::plugin::common::Image{ url:url34, layout:layout34, width:width34, height:height34, blurhash:blurhash34, } = e;
                                    let vec35 = (url34.into_bytes()).into_boxed_slice();
                                    let ptr35 = vec35.as_ptr().cast::<u8>();
                                    let len35 = vec35.len();
                                    ::core::mem::forget(vec35);
                                    *base.add(8*::core::mem::size_of::<*const u8>()).cast::<usize>() = len35;
                                    *base.add(7*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr35.cast_mut();
                                    *base.add(9*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout34.clone() as i32) as u8;
                                    match width34 {
                                      Some(e) => {
                                        *base.add(4+9*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                        *base.add(8+9*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                      },
                                      None => {
                                        {
                                          *base.add(4+9*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                        }
                                      },
                                    };match height34 {
                                      Some(e) => {
                                        *base.add(12+9*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                        *base.add(16+9*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                      },
                                      None => {
                                        {
                                          *base.add(12+9*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                        }
                                      },
                                    };match blurhash34 {
                                      Some(e) => {
                                        *base.add(16+10*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                        let vec36 = (e.into_bytes()).into_boxed_slice();
                                        let ptr36 = vec36.as_ptr().cast::<u8>();
                                        let len36 = vec36.len();
                                        ::core::mem::forget(vec36);
                                        *base.add(16+12*::core::mem::size_of::<*const u8>()).cast::<usize>() = len36;
                                        *base.add(16+11*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr36.cast_mut();
                                      },
                                      None => {
                                        {
                                          *base.add(16+10*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                        }
                                      },
                                    };},
                                    None => {
                                      {
                                        *base.add(6*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                      }
                                    },
                                  };match medium33 {
                                    Some(e) => {
                                      *base.add(16+13*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                      let super::super::bex::plugin::common::Image{ url:url37, layout:layout37, width:width37, height:height37, blurhash:blurhash37, } = e;
                                      let vec38 = (url37.into_bytes()).into_boxed_slice();
                                      let ptr38 = vec38.as_ptr().cast::<u8>();
                                      let len38 = vec38.len();
                                      ::core::mem::forget(vec38);
                                      *base.add(16+15*::core::mem::size_of::<*const u8>()).cast::<usize>() = len38;
                                      *base.add(16+14*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr38.cast_mut();
                                      *base.add(16+16*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout37.clone() as i32) as u8;
                                      match width37 {
                                        Some(e) => {
                                          *base.add(20+16*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                          *base.add(24+16*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                        },
                                        None => {
                                          {
                                            *base.add(20+16*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                          }
                                        },
                                      };match height37 {
                                        Some(e) => {
                                          *base.add(28+16*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                          *base.add(32+16*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                        },
                                        None => {
                                          {
                                            *base.add(28+16*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                          }
                                        },
                                      };match blurhash37 {
                                        Some(e) => {
                                          *base.add(32+17*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                          let vec39 = (e.into_bytes()).into_boxed_slice();
                                          let ptr39 = vec39.as_ptr().cast::<u8>();
                                          let len39 = vec39.len();
                                          ::core::mem::forget(vec39);
                                          *base.add(32+19*::core::mem::size_of::<*const u8>()).cast::<usize>() = len39;
                                          *base.add(32+18*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr39.cast_mut();
                                        },
                                        None => {
                                          {
                                            *base.add(32+17*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                          }
                                        },
                                      };},
                                      None => {
                                        {
                                          *base.add(16+13*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                        }
                                      },
                                    };match high33 {
                                      Some(e) => {
                                        *base.add(32+20*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                        let super::super::bex::plugin::common::Image{ url:url40, layout:layout40, width:width40, height:height40, blurhash:blurhash40, } = e;
                                        let vec41 = (url40.into_bytes()).into_boxed_slice();
                                        let ptr41 = vec41.as_ptr().cast::<u8>();
                                        let len41 = vec41.len();
                                        ::core::mem::forget(vec41);
                                        *base.add(32+22*::core::mem::size_of::<*const u8>()).cast::<usize>() = len41;
                                        *base.add(32+21*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr41.cast_mut();
                                        *base.add(32+23*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout40.clone() as i32) as u8;
                                        match width40 {
                                          Some(e) => {
                                            *base.add(36+23*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                            *base.add(40+23*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                          },
                                          None => {
                                            {
                                              *base.add(36+23*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                            }
                                          },
                                        };match height40 {
                                          Some(e) => {
                                            *base.add(44+23*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                            *base.add(48+23*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                          },
                                          None => {
                                            {
                                              *base.add(44+23*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                            }
                                          },
                                        };match blurhash40 {
                                          Some(e) => {
                                            *base.add(48+24*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                            let vec42 = (e.into_bytes()).into_boxed_slice();
                                            let ptr42 = vec42.as_ptr().cast::<u8>();
                                            let len42 = vec42.len();
                                            ::core::mem::forget(vec42);
                                            *base.add(48+26*::core::mem::size_of::<*const u8>()).cast::<usize>() = len42;
                                            *base.add(48+25*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr42.cast_mut();
                                          },
                                          None => {
                                            {
                                              *base.add(48+24*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                            }
                                          },
                                        };},
                                        None => {
                                          {
                                            *base.add(32+20*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                          }
                                        },
                                      };match backdrop33 {
                                        Some(e) => {
                                          *base.add(48+27*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                          let super::super::bex::plugin::common::Image{ url:url43, layout:layout43, width:width43, height:height43, blurhash:blurhash43, } = e;
                                          let vec44 = (url43.into_bytes()).into_boxed_slice();
                                          let ptr44 = vec44.as_ptr().cast::<u8>();
                                          let len44 = vec44.len();
                                          ::core::mem::forget(vec44);
                                          *base.add(48+29*::core::mem::size_of::<*const u8>()).cast::<usize>() = len44;
                                          *base.add(48+28*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr44.cast_mut();
                                          *base.add(48+30*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout43.clone() as i32) as u8;
                                          match width43 {
                                            Some(e) => {
                                              *base.add(52+30*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                              *base.add(56+30*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                            },
                                            None => {
                                              {
                                                *base.add(52+30*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                              }
                                            },
                                          };match height43 {
                                            Some(e) => {
                                              *base.add(60+30*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                              *base.add(64+30*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                            },
                                            None => {
                                              {
                                                *base.add(60+30*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                              }
                                            },
                                          };match blurhash43 {
                                            Some(e) => {
                                              *base.add(64+31*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                              let vec45 = (e.into_bytes()).into_boxed_slice();
                                              let ptr45 = vec45.as_ptr().cast::<u8>();
                                              let len45 = vec45.len();
                                              ::core::mem::forget(vec45);
                                              *base.add(64+33*::core::mem::size_of::<*const u8>()).cast::<usize>() = len45;
                                              *base.add(64+32*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr45.cast_mut();
                                            },
                                            None => {
                                              {
                                                *base.add(64+31*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                              }
                                            },
                                          };},
                                          None => {
                                            {
                                              *base.add(48+27*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                            }
                                          },
                                        };match logo33 {
                                          Some(e) => {
                                            *base.add(64+34*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                            let super::super::bex::plugin::common::Image{ url:url46, layout:layout46, width:width46, height:height46, blurhash:blurhash46, } = e;
                                            let vec47 = (url46.into_bytes()).into_boxed_slice();
                                            let ptr47 = vec47.as_ptr().cast::<u8>();
                                            let len47 = vec47.len();
                                            ::core::mem::forget(vec47);
                                            *base.add(64+36*::core::mem::size_of::<*const u8>()).cast::<usize>() = len47;
                                            *base.add(64+35*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr47.cast_mut();
                                            *base.add(64+37*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout46.clone() as i32) as u8;
                                            match width46 {
                                              Some(e) => {
                                                *base.add(68+37*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                *base.add(72+37*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                              },
                                              None => {
                                                {
                                                  *base.add(68+37*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                }
                                              },
                                            };match height46 {
                                              Some(e) => {
                                                *base.add(76+37*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                *base.add(80+37*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                              },
                                              None => {
                                                {
                                                  *base.add(76+37*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                }
                                              },
                                            };match blurhash46 {
                                              Some(e) => {
                                                *base.add(80+38*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                let vec48 = (e.into_bytes()).into_boxed_slice();
                                                let ptr48 = vec48.as_ptr().cast::<u8>();
                                                let len48 = vec48.len();
                                                ::core::mem::forget(vec48);
                                                *base.add(80+40*::core::mem::size_of::<*const u8>()).cast::<usize>() = len48;
                                                *base.add(80+39*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr48.cast_mut();
                                              },
                                              None => {
                                                {
                                                  *base.add(80+38*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                }
                                              },
                                            };},
                                            None => {
                                              {
                                                *base.add(64+34*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                              }
                                            },
                                          };},
                                          None => {
                                            {
                                              *base.add(5*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                            }
                                          },
                                        };match original_title30 {
                                          Some(e) => {
                                            *base.add(80+41*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                            let vec49 = (e.into_bytes()).into_boxed_slice();
                                            let ptr49 = vec49.as_ptr().cast::<u8>();
                                            let len49 = vec49.len();
                                            ::core::mem::forget(vec49);
                                            *base.add(80+43*::core::mem::size_of::<*const u8>()).cast::<usize>() = len49;
                                            *base.add(80+42*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr49.cast_mut();
                                          },
                                          None => {
                                            {
                                              *base.add(80+41*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                            }
                                          },
                                        };match tagline30 {
                                          Some(e) => {
                                            *base.add(80+44*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                            let vec50 = (e.into_bytes()).into_boxed_slice();
                                            let ptr50 = vec50.as_ptr().cast::<u8>();
                                            let len50 = vec50.len();
                                            ::core::mem::forget(vec50);
                                            *base.add(80+46*::core::mem::size_of::<*const u8>()).cast::<usize>() = len50;
                                            *base.add(80+45*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr50.cast_mut();
                                          },
                                          None => {
                                            {
                                              *base.add(80+44*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                            }
                                          },
                                        };match year30 {
                                          Some(e) => {
                                            *base.add(80+47*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                            let vec51 = (e.into_bytes()).into_boxed_slice();
                                            let ptr51 = vec51.as_ptr().cast::<u8>();
                                            let len51 = vec51.len();
                                            ::core::mem::forget(vec51);
                                            *base.add(80+49*::core::mem::size_of::<*const u8>()).cast::<usize>() = len51;
                                            *base.add(80+48*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr51.cast_mut();
                                          },
                                          None => {
                                            {
                                              *base.add(80+47*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                            }
                                          },
                                        };match score30 {
                                          Some(e) => {
                                            *base.add(80+50*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                            *base.add(84+50*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                          },
                                          None => {
                                            {
                                              *base.add(80+50*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                            }
                                          },
                                        };let vec53 = genres30;
                                        let len53 = vec53.len();
                                        let layout53 = _rt::alloc::Layout::from_size_align(vec53.len() * (2*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>()).unwrap();
                                        let (result53, _cleanup53) = wit_bindgen::rt::Cleanup::new(layout53);if let Some(cleanup) = _cleanup53 { cleanup.forget(); }
                                        for (i, e) in vec53.into_iter().enumerate() {
                                          let base = result53.add(i * (2*::core::mem::size_of::<*const u8>()));
                                          {
                                            let vec52 = (e.into_bytes()).into_boxed_slice();
                                            let ptr52 = vec52.as_ptr().cast::<u8>();
                                            let len52 = vec52.len();
                                            ::core::mem::forget(vec52);
                                            *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len52;
                                            *base.add(0).cast::<*mut u8>() = ptr52.cast_mut();
                                          }
                                        }
                                        *base.add(88+51*::core::mem::size_of::<*const u8>()).cast::<usize>() = len53;
                                        *base.add(88+50*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result53;
                                        match status30 {
                                          Some(e) => {
                                            *base.add(88+52*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                            *base.add(89+52*::core::mem::size_of::<*const u8>()).cast::<u8>() = (e.clone() as i32) as u8;
                                          },
                                          None => {
                                            {
                                              *base.add(88+52*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                            }
                                          },
                                        };match content_rating30 {
                                          Some(e) => {
                                            *base.add(88+53*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                            let vec54 = (e.into_bytes()).into_boxed_slice();
                                            let ptr54 = vec54.as_ptr().cast::<u8>();
                                            let len54 = vec54.len();
                                            ::core::mem::forget(vec54);
                                            *base.add(88+55*::core::mem::size_of::<*const u8>()).cast::<usize>() = len54;
                                            *base.add(88+54*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr54.cast_mut();
                                          },
                                          None => {
                                            {
                                              *base.add(88+53*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                            }
                                          },
                                        };match url30 {
                                          Some(e) => {
                                            *base.add(88+56*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                            let vec55 = (e.into_bytes()).into_boxed_slice();
                                            let ptr55 = vec55.as_ptr().cast::<u8>();
                                            let len55 = vec55.len();
                                            ::core::mem::forget(vec55);
                                            *base.add(88+58*::core::mem::size_of::<*const u8>()).cast::<usize>() = len55;
                                            *base.add(88+57*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr55.cast_mut();
                                          },
                                          None => {
                                            {
                                              *base.add(88+56*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                            }
                                          },
                                        };let vec59 = ids30;
                                        let len59 = vec59.len();
                                        let layout59 = _rt::alloc::Layout::from_size_align(vec59.len() * (4*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>()).unwrap();
                                        let (result59, _cleanup59) = wit_bindgen::rt::Cleanup::new(layout59);if let Some(cleanup) = _cleanup59 { cleanup.forget(); }
                                        for (i, e) in vec59.into_iter().enumerate() {
                                          let base = result59.add(i * (4*::core::mem::size_of::<*const u8>()));
                                          {
                                            let super::super::bex::plugin::common::LinkedId{ source:source56, id:id56, } = e;
                                            let vec57 = (source56.into_bytes()).into_boxed_slice();
                                            let ptr57 = vec57.as_ptr().cast::<u8>();
                                            let len57 = vec57.len();
                                            ::core::mem::forget(vec57);
                                            *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len57;
                                            *base.add(0).cast::<*mut u8>() = ptr57.cast_mut();
                                            let vec58 = (id56.into_bytes()).into_boxed_slice();
                                            let ptr58 = vec58.as_ptr().cast::<u8>();
                                            let len58 = vec58.len();
                                            ::core::mem::forget(vec58);
                                            *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len58;
                                            *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr58.cast_mut();
                                          }
                                        }
                                        *base.add(88+60*::core::mem::size_of::<*const u8>()).cast::<usize>() = len59;
                                        *base.add(88+59*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result59;
                                        let vec63 = extra30;
                                        let len63 = vec63.len();
                                        let layout63 = _rt::alloc::Layout::from_size_align(vec63.len() * (4*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>()).unwrap();
                                        let (result63, _cleanup63) = wit_bindgen::rt::Cleanup::new(layout63);if let Some(cleanup) = _cleanup63 { cleanup.forget(); }
                                        for (i, e) in vec63.into_iter().enumerate() {
                                          let base = result63.add(i * (4*::core::mem::size_of::<*const u8>()));
                                          {
                                            let super::super::bex::plugin::common::Attr{ key:key60, value:value60, } = e;
                                            let vec61 = (key60.into_bytes()).into_boxed_slice();
                                            let ptr61 = vec61.as_ptr().cast::<u8>();
                                            let len61 = vec61.len();
                                            ::core::mem::forget(vec61);
                                            *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len61;
                                            *base.add(0).cast::<*mut u8>() = ptr61.cast_mut();
                                            let vec62 = (value60.into_bytes()).into_boxed_slice();
                                            let ptr62 = vec62.as_ptr().cast::<u8>();
                                            let len62 = vec62.len();
                                            ::core::mem::forget(vec62);
                                            *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len62;
                                            *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr62.cast_mut();
                                          }
                                        }
                                        *base.add(88+62*::core::mem::size_of::<*const u8>()).cast::<usize>() = len63;
                                        *base.add(88+61*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result63;
                                      }
                                    }
                                    *ptr28.add(2*::core::mem::size_of::<*const u8>()).cast::<usize>() = len64;
                                    *ptr28.add(::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result64;
                                    let vec72 = categories29;
                                    let len72 = vec72.len();
                                    let layout72 = _rt::alloc::Layout::from_size_align(vec72.len() * (16+14*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>()).unwrap();
                                    let (result72, _cleanup72) = wit_bindgen::rt::Cleanup::new(layout72);if let Some(cleanup) = _cleanup72 { cleanup.forget(); }
                                    for (i, e) in vec72.into_iter().enumerate() {
                                      let base = result72.add(i * (16+14*::core::mem::size_of::<*const u8>()));
                                      {
                                        let super::super::bex::plugin::common::CategoryLink{ id:id65, title:title65, subtitle:subtitle65, image:image65, } = e;
                                        let vec66 = (id65.into_bytes()).into_boxed_slice();
                                        let ptr66 = vec66.as_ptr().cast::<u8>();
                                        let len66 = vec66.len();
                                        ::core::mem::forget(vec66);
                                        *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len66;
                                        *base.add(0).cast::<*mut u8>() = ptr66.cast_mut();
                                        let vec67 = (title65.into_bytes()).into_boxed_slice();
                                        let ptr67 = vec67.as_ptr().cast::<u8>();
                                        let len67 = vec67.len();
                                        ::core::mem::forget(vec67);
                                        *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len67;
                                        *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr67.cast_mut();
                                        match subtitle65 {
                                          Some(e) => {
                                            *base.add(4*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                            let vec68 = (e.into_bytes()).into_boxed_slice();
                                            let ptr68 = vec68.as_ptr().cast::<u8>();
                                            let len68 = vec68.len();
                                            ::core::mem::forget(vec68);
                                            *base.add(6*::core::mem::size_of::<*const u8>()).cast::<usize>() = len68;
                                            *base.add(5*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr68.cast_mut();
                                          },
                                          None => {
                                            {
                                              *base.add(4*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                            }
                                          },
                                        };match image65 {
                                          Some(e) => {
                                            *base.add(7*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                            let super::super::bex::plugin::common::Image{ url:url69, layout:layout69, width:width69, height:height69, blurhash:blurhash69, } = e;
                                            let vec70 = (url69.into_bytes()).into_boxed_slice();
                                            let ptr70 = vec70.as_ptr().cast::<u8>();
                                            let len70 = vec70.len();
                                            ::core::mem::forget(vec70);
                                            *base.add(9*::core::mem::size_of::<*const u8>()).cast::<usize>() = len70;
                                            *base.add(8*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr70.cast_mut();
                                            *base.add(10*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout69.clone() as i32) as u8;
                                            match width69 {
                                              Some(e) => {
                                                *base.add(4+10*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                *base.add(8+10*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                              },
                                              None => {
                                                {
                                                  *base.add(4+10*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                }
                                              },
                                            };match height69 {
                                              Some(e) => {
                                                *base.add(12+10*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                *base.add(16+10*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                              },
                                              None => {
                                                {
                                                  *base.add(12+10*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                }
                                              },
                                            };match blurhash69 {
                                              Some(e) => {
                                                *base.add(16+11*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                let vec71 = (e.into_bytes()).into_boxed_slice();
                                                let ptr71 = vec71.as_ptr().cast::<u8>();
                                                let len71 = vec71.len();
                                                ::core::mem::forget(vec71);
                                                *base.add(16+13*::core::mem::size_of::<*const u8>()).cast::<usize>() = len71;
                                                *base.add(16+12*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr71.cast_mut();
                                              },
                                              None => {
                                                {
                                                  *base.add(16+11*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                }
                                              },
                                            };},
                                            None => {
                                              {
                                                *base.add(7*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                              }
                                            },
                                          };}
                                        }
                                        *ptr28.add(4*::core::mem::size_of::<*const u8>()).cast::<usize>() = len72;
                                        *ptr28.add(3*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result72;
                                        match next_page29 {
                                          Some(e) => {
                                            *ptr28.add(5*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                            let vec73 = (e.into_bytes()).into_boxed_slice();
                                            let ptr73 = vec73.as_ptr().cast::<u8>();
                                            let len73 = vec73.len();
                                            ::core::mem::forget(vec73);
                                            *ptr28.add(7*::core::mem::size_of::<*const u8>()).cast::<usize>() = len73;
                                            *ptr28.add(6*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr73.cast_mut();
                                          },
                                          None => {
                                            {
                                              *ptr28.add(5*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                            }
                                          },
                                        };} },
                                        Err(e) => { {
                                          *ptr28.add(0).cast::<u8>() = (1i32) as u8;
                                          use super::super::bex::plugin::common::PluginError as V78;
                                          match e {
                                            V78::Network(e) => {
                                              *ptr28.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                              let vec74 = (e.into_bytes()).into_boxed_slice();
                                              let ptr74 = vec74.as_ptr().cast::<u8>();
                                              let len74 = vec74.len();
                                              ::core::mem::forget(vec74);
                                              *ptr28.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len74;
                                              *ptr28.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr74.cast_mut();
                                            },
                                            V78::Parse(e) => {
                                              *ptr28.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                              let vec75 = (e.into_bytes()).into_boxed_slice();
                                              let ptr75 = vec75.as_ptr().cast::<u8>();
                                              let len75 = vec75.len();
                                              ::core::mem::forget(vec75);
                                              *ptr28.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len75;
                                              *ptr28.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr75.cast_mut();
                                            },
                                            V78::NotFound=> {
                                              {
                                                *ptr28.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (2i32) as u8;
                                              }
                                            }
                                            V78::Unauthorized=> {
                                              {
                                                *ptr28.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (3i32) as u8;
                                              }
                                            }
                                            V78::Forbidden=> {
                                              {
                                                *ptr28.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (4i32) as u8;
                                              }
                                            }
                                            V78::RateLimited(e) => {
                                              *ptr28.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (5i32) as u8;
                                              match e {
                                                Some(e) => {
                                                  *ptr28.add(2*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                  *ptr28.add(4+2*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                },
                                                None => {
                                                  {
                                                    *ptr28.add(2*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                  }
                                                },
                                              };},
                                              V78::Timeout=> {
                                                {
                                                  *ptr28.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (6i32) as u8;
                                                }
                                              }
                                              V78::Cancelled=> {
                                                {
                                                  *ptr28.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (7i32) as u8;
                                                }
                                              }
                                              V78::Unsupported=> {
                                                {
                                                  *ptr28.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (8i32) as u8;
                                                }
                                              }
                                              V78::InvalidInput(e) => {
                                                *ptr28.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (9i32) as u8;
                                                let vec76 = (e.into_bytes()).into_boxed_slice();
                                                let ptr76 = vec76.as_ptr().cast::<u8>();
                                                let len76 = vec76.len();
                                                ::core::mem::forget(vec76);
                                                *ptr28.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len76;
                                                *ptr28.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr76.cast_mut();
                                              },
                                              V78::Internal(e) => {
                                                *ptr28.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (10i32) as u8;
                                                let vec77 = (e.into_bytes()).into_boxed_slice();
                                                let ptr77 = vec77.as_ptr().cast::<u8>();
                                                let len77 = vec77.len();
                                                ::core::mem::forget(vec77);
                                                *ptr28.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len77;
                                                *ptr28.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr77.cast_mut();
                                              },
                                            }
                                          } },
                                        };ptr28
                                      } }
                                      #[doc(hidden)]
                                      #[allow(non_snake_case)]
                                      pub unsafe fn __post_return_get_category<T_: Guest>(arg0: *mut u8,) { unsafe {
                                        let l0 = i32::from(*arg0.add(0).cast::<u8>());
                                        match l0 {
                                          0 => {
                                            let l1 = *arg0.add(::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                            let l2 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                            let base72 = l1;
                                            let len72 = l2;
                                            for i in 0..len72 {
                                              let base = base72.add(i * (88+63*::core::mem::size_of::<*const u8>()));
                                              {
                                                let l3 = *base.add(0).cast::<*mut u8>();
                                                let l4 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                _rt::cabi_dealloc(l3, l4, 1);
                                                let l5 = *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                let l6 = *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                _rt::cabi_dealloc(l5, l6, 1);
                                                let l7 = i32::from(*base.add(5*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                match l7 {
                                                  0 => (),
                                                  _ => {
                                                    let l8 = i32::from(*base.add(6*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                    match l8 {
                                                      0 => (),
                                                      _ => {
                                                        let l9 = *base.add(7*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                        let l10 = *base.add(8*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                        _rt::cabi_dealloc(l9, l10, 1);
                                                        let l11 = i32::from(*base.add(16+10*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                        match l11 {
                                                          0 => (),
                                                          _ => {
                                                            let l12 = *base.add(16+11*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                            let l13 = *base.add(16+12*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                            _rt::cabi_dealloc(l12, l13, 1);
                                                          },
                                                        }
                                                      },
                                                    }
                                                    let l14 = i32::from(*base.add(16+13*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                    match l14 {
                                                      0 => (),
                                                      _ => {
                                                        let l15 = *base.add(16+14*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                        let l16 = *base.add(16+15*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                        _rt::cabi_dealloc(l15, l16, 1);
                                                        let l17 = i32::from(*base.add(32+17*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                        match l17 {
                                                          0 => (),
                                                          _ => {
                                                            let l18 = *base.add(32+18*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                            let l19 = *base.add(32+19*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                            _rt::cabi_dealloc(l18, l19, 1);
                                                          },
                                                        }
                                                      },
                                                    }
                                                    let l20 = i32::from(*base.add(32+20*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                    match l20 {
                                                      0 => (),
                                                      _ => {
                                                        let l21 = *base.add(32+21*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                        let l22 = *base.add(32+22*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                        _rt::cabi_dealloc(l21, l22, 1);
                                                        let l23 = i32::from(*base.add(48+24*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                        match l23 {
                                                          0 => (),
                                                          _ => {
                                                            let l24 = *base.add(48+25*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                            let l25 = *base.add(48+26*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                            _rt::cabi_dealloc(l24, l25, 1);
                                                          },
                                                        }
                                                      },
                                                    }
                                                    let l26 = i32::from(*base.add(48+27*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                    match l26 {
                                                      0 => (),
                                                      _ => {
                                                        let l27 = *base.add(48+28*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                        let l28 = *base.add(48+29*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                        _rt::cabi_dealloc(l27, l28, 1);
                                                        let l29 = i32::from(*base.add(64+31*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                        match l29 {
                                                          0 => (),
                                                          _ => {
                                                            let l30 = *base.add(64+32*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                            let l31 = *base.add(64+33*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                            _rt::cabi_dealloc(l30, l31, 1);
                                                          },
                                                        }
                                                      },
                                                    }
                                                    let l32 = i32::from(*base.add(64+34*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                    match l32 {
                                                      0 => (),
                                                      _ => {
                                                        let l33 = *base.add(64+35*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                        let l34 = *base.add(64+36*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                        _rt::cabi_dealloc(l33, l34, 1);
                                                        let l35 = i32::from(*base.add(80+38*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                        match l35 {
                                                          0 => (),
                                                          _ => {
                                                            let l36 = *base.add(80+39*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                            let l37 = *base.add(80+40*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                            _rt::cabi_dealloc(l36, l37, 1);
                                                          },
                                                        }
                                                      },
                                                    }
                                                  },
                                                }
                                                let l38 = i32::from(*base.add(80+41*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                match l38 {
                                                  0 => (),
                                                  _ => {
                                                    let l39 = *base.add(80+42*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                    let l40 = *base.add(80+43*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                    _rt::cabi_dealloc(l39, l40, 1);
                                                  },
                                                }
                                                let l41 = i32::from(*base.add(80+44*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                match l41 {
                                                  0 => (),
                                                  _ => {
                                                    let l42 = *base.add(80+45*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                    let l43 = *base.add(80+46*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                    _rt::cabi_dealloc(l42, l43, 1);
                                                  },
                                                }
                                                let l44 = i32::from(*base.add(80+47*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                match l44 {
                                                  0 => (),
                                                  _ => {
                                                    let l45 = *base.add(80+48*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                    let l46 = *base.add(80+49*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                    _rt::cabi_dealloc(l45, l46, 1);
                                                  },
                                                }
                                                let l47 = *base.add(88+50*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                let l48 = *base.add(88+51*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                let base51 = l47;
                                                let len51 = l48;
                                                for i in 0..len51 {
                                                  let base = base51.add(i * (2*::core::mem::size_of::<*const u8>()));
                                                  {
                                                    let l49 = *base.add(0).cast::<*mut u8>();
                                                    let l50 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                    _rt::cabi_dealloc(l49, l50, 1);
                                                  }
                                                }
                                                _rt::cabi_dealloc(base51, len51 * (2*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                                let l52 = i32::from(*base.add(88+53*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                match l52 {
                                                  0 => (),
                                                  _ => {
                                                    let l53 = *base.add(88+54*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                    let l54 = *base.add(88+55*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                    _rt::cabi_dealloc(l53, l54, 1);
                                                  },
                                                }
                                                let l55 = i32::from(*base.add(88+56*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                match l55 {
                                                  0 => (),
                                                  _ => {
                                                    let l56 = *base.add(88+57*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                    let l57 = *base.add(88+58*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                    _rt::cabi_dealloc(l56, l57, 1);
                                                  },
                                                }
                                                let l58 = *base.add(88+59*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                let l59 = *base.add(88+60*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                let base64 = l58;
                                                let len64 = l59;
                                                for i in 0..len64 {
                                                  let base = base64.add(i * (4*::core::mem::size_of::<*const u8>()));
                                                  {
                                                    let l60 = *base.add(0).cast::<*mut u8>();
                                                    let l61 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                    _rt::cabi_dealloc(l60, l61, 1);
                                                    let l62 = *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                    let l63 = *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                    _rt::cabi_dealloc(l62, l63, 1);
                                                  }
                                                }
                                                _rt::cabi_dealloc(base64, len64 * (4*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                                let l65 = *base.add(88+61*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                let l66 = *base.add(88+62*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                let base71 = l65;
                                                let len71 = l66;
                                                for i in 0..len71 {
                                                  let base = base71.add(i * (4*::core::mem::size_of::<*const u8>()));
                                                  {
                                                    let l67 = *base.add(0).cast::<*mut u8>();
                                                    let l68 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                    _rt::cabi_dealloc(l67, l68, 1);
                                                    let l69 = *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                    let l70 = *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                    _rt::cabi_dealloc(l69, l70, 1);
                                                  }
                                                }
                                                _rt::cabi_dealloc(base71, len71 * (4*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                              }
                                            }
                                            _rt::cabi_dealloc(base72, len72 * (88+63*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                            let l73 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                            let l74 = *arg0.add(4*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                            let base88 = l73;
                                            let len88 = l74;
                                            for i in 0..len88 {
                                              let base = base88.add(i * (16+14*::core::mem::size_of::<*const u8>()));
                                              {
                                                let l75 = *base.add(0).cast::<*mut u8>();
                                                let l76 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                _rt::cabi_dealloc(l75, l76, 1);
                                                let l77 = *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                let l78 = *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                _rt::cabi_dealloc(l77, l78, 1);
                                                let l79 = i32::from(*base.add(4*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                match l79 {
                                                  0 => (),
                                                  _ => {
                                                    let l80 = *base.add(5*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                    let l81 = *base.add(6*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                    _rt::cabi_dealloc(l80, l81, 1);
                                                  },
                                                }
                                                let l82 = i32::from(*base.add(7*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                match l82 {
                                                  0 => (),
                                                  _ => {
                                                    let l83 = *base.add(8*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                    let l84 = *base.add(9*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                    _rt::cabi_dealloc(l83, l84, 1);
                                                    let l85 = i32::from(*base.add(16+11*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                    match l85 {
                                                      0 => (),
                                                      _ => {
                                                        let l86 = *base.add(16+12*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                        let l87 = *base.add(16+13*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                        _rt::cabi_dealloc(l86, l87, 1);
                                                      },
                                                    }
                                                  },
                                                }
                                              }
                                            }
                                            _rt::cabi_dealloc(base88, len88 * (16+14*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                            let l89 = i32::from(*arg0.add(5*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                            match l89 {
                                              0 => (),
                                              _ => {
                                                let l90 = *arg0.add(6*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                let l91 = *arg0.add(7*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                _rt::cabi_dealloc(l90, l91, 1);
                                              },
                                            }
                                          },
                                          _ => {
                                            let l92 = i32::from(*arg0.add(::core::mem::size_of::<*const u8>()).cast::<u8>());
                                            match l92 {
                                              0 => {
                                                let l93 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                let l94 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                _rt::cabi_dealloc(l93, l94, 1);
                                              },
                                              1 => {
                                                let l95 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                let l96 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                _rt::cabi_dealloc(l95, l96, 1);
                                              },
                                              2 => (),
                                              3 => (),
                                              4 => (),
                                              5 => (),
                                              6 => (),
                                              7 => (),
                                              8 => (),
                                              9 => {
                                                let l97 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                let l98 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                _rt::cabi_dealloc(l97, l98, 1);
                                              },
                                              _ => {
                                                let l99 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                let l100 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                _rt::cabi_dealloc(l99, l100, 1);
                                              },
                                            }
                                          },
                                        }
                                      } }
                                      #[doc(hidden)]
                                      #[allow(non_snake_case, unused_unsafe)]
                                      pub unsafe fn _export_search_cabi<T_: Guest>(arg0: *mut u8,) -> *mut u8 { unsafe {#[cfg(target_arch="wasm32")]
                                      _rt::run_ctors_once();let result30 = {
                                        let l0 = *arg0.add(0).cast::<*mut u8>();
                                        let l1 = *arg0.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                        let len2 = l1;
                                        let bytes2 = _rt::Vec::from_raw_parts(l0.cast(), len2, len2);
                                        let l3 = i32::from(*arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                        let l7 = i32::from(*arg0.add(5*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                        let l11 = i32::from(*arg0.add(8*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                        let l12 = *arg0.add(9*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                        let l13 = *arg0.add(10*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                        let base17 = l12;
                                        let len17 = l13;
                                        let mut result17 = _rt::Vec::with_capacity(len17);
                                        for i in 0..len17 {
                                          let base = base17.add(i * (2*::core::mem::size_of::<*const u8>()));
                                          let e17 = {
                                            let l14 = *base.add(0).cast::<*mut u8>();
                                            let l15 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                            let len16 = l15;
                                            let bytes16 = _rt::Vec::from_raw_parts(l14.cast(), len16, len16);

                                            _rt::string_lift(bytes16)
                                          };
                                          result17.push(e17);
                                        }
                                        _rt::cabi_dealloc(base17, len17 * (2*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                        let l18 = *arg0.add(11*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                        let l19 = *arg0.add(12*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                        let len20 = l19;
                                        let bytes20 = _rt::Vec::from_raw_parts(l18.cast(), len20, len20);
                                        let l21 = i32::from(*arg0.add(13*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                        let l23 = i32::from(*arg0.add(14*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                        let l27 = i32::from(*arg0.add(17*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                        let l29 = i32::from(*arg0.add(8+17*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                        T_::search(super::super::bex::plugin::common::RequestContext{
                                          request_id: _rt::string_lift(bytes2),
                                          locale: match l3 {
                                            0 => None,
                                            1 => {
                                              let e = {
                                                let l4 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                let l5 = *arg0.add(4*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                let len6 = l5;
                                                let bytes6 = _rt::Vec::from_raw_parts(l4.cast(), len6, len6);

                                                _rt::string_lift(bytes6)
                                              };
                                              Some(e)
                                            }
                                            _ => _rt::invalid_enum_discriminant(),
                                          },
                                          region: match l7 {
                                            0 => None,
                                            1 => {
                                              let e = {
                                                let l8 = *arg0.add(6*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                let l9 = *arg0.add(7*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                let len10 = l9;
                                                let bytes10 = _rt::Vec::from_raw_parts(l8.cast(), len10, len10);

                                                _rt::string_lift(bytes10)
                                              };
                                              Some(e)
                                            }
                                            _ => _rt::invalid_enum_discriminant(),
                                          },
                                          safe_mode: _rt::bool_lift(l11 as u8),
                                          hints: result17,
                                        }, _rt::string_lift(bytes20), super::super::bex::plugin::common::SearchFilters{
                                          kind: match l21 {
                                            0 => None,
                                            1 => {
                                              let e = {
                                                let l22 = i32::from(*arg0.add(1+13*::core::mem::size_of::<*const u8>()).cast::<u8>());

                                                super::super::bex::plugin::common::MediaKind::_lift(l22 as u8)
                                              };
                                              Some(e)
                                            }
                                            _ => _rt::invalid_enum_discriminant(),
                                          },
                                          page: super::super::bex::plugin::common::PageCursor{
                                            token: match l23 {
                                              0 => None,
                                              1 => {
                                                let e = {
                                                  let l24 = *arg0.add(15*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                  let l25 = *arg0.add(16*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                  let len26 = l25;
                                                  let bytes26 = _rt::Vec::from_raw_parts(l24.cast(), len26, len26);

                                                  _rt::string_lift(bytes26)
                                                };
                                                Some(e)
                                              }
                                              _ => _rt::invalid_enum_discriminant(),
                                            },
                                            limit: match l27 {
                                              0 => None,
                                              1 => {
                                                let e = {
                                                  let l28 = *arg0.add(4+17*::core::mem::size_of::<*const u8>()).cast::<i32>();

                                                  l28 as u32
                                                };
                                                Some(e)
                                              }
                                              _ => _rt::invalid_enum_discriminant(),
                                            },
                                          },
                                          fast_match: _rt::bool_lift(l29 as u8),
                                        })
                                      };
                                      _rt::cabi_dealloc(arg0, 8+18*::core::mem::size_of::<*const u8>(), ::core::mem::size_of::<*const u8>());
                                      let ptr31 = (&raw mut _RET_AREA.0).cast::<u8>();
                                      match result30 {
                                        Ok(e) => { {
                                          *ptr31.add(0).cast::<u8>() = (0i32) as u8;
                                          let super::super::bex::plugin::common::PagedResult{ items:items32, categories:categories32, next_page:next_page32, } = e;
                                          let vec67 = items32;
                                          let len67 = vec67.len();
                                          let layout67 = _rt::alloc::Layout::from_size_align(vec67.len() * (88+63*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>()).unwrap();
                                          let (result67, _cleanup67) = wit_bindgen::rt::Cleanup::new(layout67);if let Some(cleanup) = _cleanup67 { cleanup.forget(); }
                                          for (i, e) in vec67.into_iter().enumerate() {
                                            let base = result67.add(i * (88+63*::core::mem::size_of::<*const u8>()));
                                            {
                                              let super::super::bex::plugin::common::MediaCard{ id:id33, title:title33, kind:kind33, images:images33, original_title:original_title33, tagline:tagline33, year:year33, score:score33, genres:genres33, status:status33, content_rating:content_rating33, url:url33, ids:ids33, extra:extra33, } = e;
                                              let vec34 = (id33.into_bytes()).into_boxed_slice();
                                              let ptr34 = vec34.as_ptr().cast::<u8>();
                                              let len34 = vec34.len();
                                              ::core::mem::forget(vec34);
                                              *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len34;
                                              *base.add(0).cast::<*mut u8>() = ptr34.cast_mut();
                                              let vec35 = (title33.into_bytes()).into_boxed_slice();
                                              let ptr35 = vec35.as_ptr().cast::<u8>();
                                              let len35 = vec35.len();
                                              ::core::mem::forget(vec35);
                                              *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len35;
                                              *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr35.cast_mut();
                                              match kind33 {
                                                Some(e) => {
                                                  *base.add(4*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                  *base.add(1+4*::core::mem::size_of::<*const u8>()).cast::<u8>() = (e.clone() as i32) as u8;
                                                },
                                                None => {
                                                  {
                                                    *base.add(4*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                  }
                                                },
                                              };match images33 {
                                                Some(e) => {
                                                  *base.add(5*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                  let super::super::bex::plugin::common::ImageSet{ low:low36, medium:medium36, high:high36, backdrop:backdrop36, logo:logo36, } = e;
                                                  match low36 {
                                                    Some(e) => {
                                                      *base.add(6*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                      let super::super::bex::plugin::common::Image{ url:url37, layout:layout37, width:width37, height:height37, blurhash:blurhash37, } = e;
                                                      let vec38 = (url37.into_bytes()).into_boxed_slice();
                                                      let ptr38 = vec38.as_ptr().cast::<u8>();
                                                      let len38 = vec38.len();
                                                      ::core::mem::forget(vec38);
                                                      *base.add(8*::core::mem::size_of::<*const u8>()).cast::<usize>() = len38;
                                                      *base.add(7*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr38.cast_mut();
                                                      *base.add(9*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout37.clone() as i32) as u8;
                                                      match width37 {
                                                        Some(e) => {
                                                          *base.add(4+9*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                          *base.add(8+9*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                        },
                                                        None => {
                                                          {
                                                            *base.add(4+9*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                          }
                                                        },
                                                      };match height37 {
                                                        Some(e) => {
                                                          *base.add(12+9*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                          *base.add(16+9*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                        },
                                                        None => {
                                                          {
                                                            *base.add(12+9*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                          }
                                                        },
                                                      };match blurhash37 {
                                                        Some(e) => {
                                                          *base.add(16+10*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                          let vec39 = (e.into_bytes()).into_boxed_slice();
                                                          let ptr39 = vec39.as_ptr().cast::<u8>();
                                                          let len39 = vec39.len();
                                                          ::core::mem::forget(vec39);
                                                          *base.add(16+12*::core::mem::size_of::<*const u8>()).cast::<usize>() = len39;
                                                          *base.add(16+11*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr39.cast_mut();
                                                        },
                                                        None => {
                                                          {
                                                            *base.add(16+10*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                          }
                                                        },
                                                      };},
                                                      None => {
                                                        {
                                                          *base.add(6*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                        }
                                                      },
                                                    };match medium36 {
                                                      Some(e) => {
                                                        *base.add(16+13*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                        let super::super::bex::plugin::common::Image{ url:url40, layout:layout40, width:width40, height:height40, blurhash:blurhash40, } = e;
                                                        let vec41 = (url40.into_bytes()).into_boxed_slice();
                                                        let ptr41 = vec41.as_ptr().cast::<u8>();
                                                        let len41 = vec41.len();
                                                        ::core::mem::forget(vec41);
                                                        *base.add(16+15*::core::mem::size_of::<*const u8>()).cast::<usize>() = len41;
                                                        *base.add(16+14*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr41.cast_mut();
                                                        *base.add(16+16*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout40.clone() as i32) as u8;
                                                        match width40 {
                                                          Some(e) => {
                                                            *base.add(20+16*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                            *base.add(24+16*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                          },
                                                          None => {
                                                            {
                                                              *base.add(20+16*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                            }
                                                          },
                                                        };match height40 {
                                                          Some(e) => {
                                                            *base.add(28+16*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                            *base.add(32+16*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                          },
                                                          None => {
                                                            {
                                                              *base.add(28+16*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                            }
                                                          },
                                                        };match blurhash40 {
                                                          Some(e) => {
                                                            *base.add(32+17*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                            let vec42 = (e.into_bytes()).into_boxed_slice();
                                                            let ptr42 = vec42.as_ptr().cast::<u8>();
                                                            let len42 = vec42.len();
                                                            ::core::mem::forget(vec42);
                                                            *base.add(32+19*::core::mem::size_of::<*const u8>()).cast::<usize>() = len42;
                                                            *base.add(32+18*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr42.cast_mut();
                                                          },
                                                          None => {
                                                            {
                                                              *base.add(32+17*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                            }
                                                          },
                                                        };},
                                                        None => {
                                                          {
                                                            *base.add(16+13*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                          }
                                                        },
                                                      };match high36 {
                                                        Some(e) => {
                                                          *base.add(32+20*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                          let super::super::bex::plugin::common::Image{ url:url43, layout:layout43, width:width43, height:height43, blurhash:blurhash43, } = e;
                                                          let vec44 = (url43.into_bytes()).into_boxed_slice();
                                                          let ptr44 = vec44.as_ptr().cast::<u8>();
                                                          let len44 = vec44.len();
                                                          ::core::mem::forget(vec44);
                                                          *base.add(32+22*::core::mem::size_of::<*const u8>()).cast::<usize>() = len44;
                                                          *base.add(32+21*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr44.cast_mut();
                                                          *base.add(32+23*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout43.clone() as i32) as u8;
                                                          match width43 {
                                                            Some(e) => {
                                                              *base.add(36+23*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                              *base.add(40+23*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                            },
                                                            None => {
                                                              {
                                                                *base.add(36+23*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                              }
                                                            },
                                                          };match height43 {
                                                            Some(e) => {
                                                              *base.add(44+23*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                              *base.add(48+23*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                            },
                                                            None => {
                                                              {
                                                                *base.add(44+23*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                              }
                                                            },
                                                          };match blurhash43 {
                                                            Some(e) => {
                                                              *base.add(48+24*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                              let vec45 = (e.into_bytes()).into_boxed_slice();
                                                              let ptr45 = vec45.as_ptr().cast::<u8>();
                                                              let len45 = vec45.len();
                                                              ::core::mem::forget(vec45);
                                                              *base.add(48+26*::core::mem::size_of::<*const u8>()).cast::<usize>() = len45;
                                                              *base.add(48+25*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr45.cast_mut();
                                                            },
                                                            None => {
                                                              {
                                                                *base.add(48+24*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                              }
                                                            },
                                                          };},
                                                          None => {
                                                            {
                                                              *base.add(32+20*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                            }
                                                          },
                                                        };match backdrop36 {
                                                          Some(e) => {
                                                            *base.add(48+27*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                            let super::super::bex::plugin::common::Image{ url:url46, layout:layout46, width:width46, height:height46, blurhash:blurhash46, } = e;
                                                            let vec47 = (url46.into_bytes()).into_boxed_slice();
                                                            let ptr47 = vec47.as_ptr().cast::<u8>();
                                                            let len47 = vec47.len();
                                                            ::core::mem::forget(vec47);
                                                            *base.add(48+29*::core::mem::size_of::<*const u8>()).cast::<usize>() = len47;
                                                            *base.add(48+28*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr47.cast_mut();
                                                            *base.add(48+30*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout46.clone() as i32) as u8;
                                                            match width46 {
                                                              Some(e) => {
                                                                *base.add(52+30*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                *base.add(56+30*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                              },
                                                              None => {
                                                                {
                                                                  *base.add(52+30*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                }
                                                              },
                                                            };match height46 {
                                                              Some(e) => {
                                                                *base.add(60+30*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                *base.add(64+30*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                              },
                                                              None => {
                                                                {
                                                                  *base.add(60+30*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                }
                                                              },
                                                            };match blurhash46 {
                                                              Some(e) => {
                                                                *base.add(64+31*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                let vec48 = (e.into_bytes()).into_boxed_slice();
                                                                let ptr48 = vec48.as_ptr().cast::<u8>();
                                                                let len48 = vec48.len();
                                                                ::core::mem::forget(vec48);
                                                                *base.add(64+33*::core::mem::size_of::<*const u8>()).cast::<usize>() = len48;
                                                                *base.add(64+32*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr48.cast_mut();
                                                              },
                                                              None => {
                                                                {
                                                                  *base.add(64+31*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                }
                                                              },
                                                            };},
                                                            None => {
                                                              {
                                                                *base.add(48+27*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                              }
                                                            },
                                                          };match logo36 {
                                                            Some(e) => {
                                                              *base.add(64+34*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                              let super::super::bex::plugin::common::Image{ url:url49, layout:layout49, width:width49, height:height49, blurhash:blurhash49, } = e;
                                                              let vec50 = (url49.into_bytes()).into_boxed_slice();
                                                              let ptr50 = vec50.as_ptr().cast::<u8>();
                                                              let len50 = vec50.len();
                                                              ::core::mem::forget(vec50);
                                                              *base.add(64+36*::core::mem::size_of::<*const u8>()).cast::<usize>() = len50;
                                                              *base.add(64+35*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr50.cast_mut();
                                                              *base.add(64+37*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout49.clone() as i32) as u8;
                                                              match width49 {
                                                                Some(e) => {
                                                                  *base.add(68+37*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                  *base.add(72+37*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                },
                                                                None => {
                                                                  {
                                                                    *base.add(68+37*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                  }
                                                                },
                                                              };match height49 {
                                                                Some(e) => {
                                                                  *base.add(76+37*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                  *base.add(80+37*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                },
                                                                None => {
                                                                  {
                                                                    *base.add(76+37*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                  }
                                                                },
                                                              };match blurhash49 {
                                                                Some(e) => {
                                                                  *base.add(80+38*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                  let vec51 = (e.into_bytes()).into_boxed_slice();
                                                                  let ptr51 = vec51.as_ptr().cast::<u8>();
                                                                  let len51 = vec51.len();
                                                                  ::core::mem::forget(vec51);
                                                                  *base.add(80+40*::core::mem::size_of::<*const u8>()).cast::<usize>() = len51;
                                                                  *base.add(80+39*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr51.cast_mut();
                                                                },
                                                                None => {
                                                                  {
                                                                    *base.add(80+38*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                  }
                                                                },
                                                              };},
                                                              None => {
                                                                {
                                                                  *base.add(64+34*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                }
                                                              },
                                                            };},
                                                            None => {
                                                              {
                                                                *base.add(5*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                              }
                                                            },
                                                          };match original_title33 {
                                                            Some(e) => {
                                                              *base.add(80+41*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                              let vec52 = (e.into_bytes()).into_boxed_slice();
                                                              let ptr52 = vec52.as_ptr().cast::<u8>();
                                                              let len52 = vec52.len();
                                                              ::core::mem::forget(vec52);
                                                              *base.add(80+43*::core::mem::size_of::<*const u8>()).cast::<usize>() = len52;
                                                              *base.add(80+42*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr52.cast_mut();
                                                            },
                                                            None => {
                                                              {
                                                                *base.add(80+41*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                              }
                                                            },
                                                          };match tagline33 {
                                                            Some(e) => {
                                                              *base.add(80+44*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                              let vec53 = (e.into_bytes()).into_boxed_slice();
                                                              let ptr53 = vec53.as_ptr().cast::<u8>();
                                                              let len53 = vec53.len();
                                                              ::core::mem::forget(vec53);
                                                              *base.add(80+46*::core::mem::size_of::<*const u8>()).cast::<usize>() = len53;
                                                              *base.add(80+45*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr53.cast_mut();
                                                            },
                                                            None => {
                                                              {
                                                                *base.add(80+44*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                              }
                                                            },
                                                          };match year33 {
                                                            Some(e) => {
                                                              *base.add(80+47*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                              let vec54 = (e.into_bytes()).into_boxed_slice();
                                                              let ptr54 = vec54.as_ptr().cast::<u8>();
                                                              let len54 = vec54.len();
                                                              ::core::mem::forget(vec54);
                                                              *base.add(80+49*::core::mem::size_of::<*const u8>()).cast::<usize>() = len54;
                                                              *base.add(80+48*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr54.cast_mut();
                                                            },
                                                            None => {
                                                              {
                                                                *base.add(80+47*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                              }
                                                            },
                                                          };match score33 {
                                                            Some(e) => {
                                                              *base.add(80+50*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                              *base.add(84+50*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                            },
                                                            None => {
                                                              {
                                                                *base.add(80+50*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                              }
                                                            },
                                                          };let vec56 = genres33;
                                                          let len56 = vec56.len();
                                                          let layout56 = _rt::alloc::Layout::from_size_align(vec56.len() * (2*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>()).unwrap();
                                                          let (result56, _cleanup56) = wit_bindgen::rt::Cleanup::new(layout56);if let Some(cleanup) = _cleanup56 { cleanup.forget(); }
                                                          for (i, e) in vec56.into_iter().enumerate() {
                                                            let base = result56.add(i * (2*::core::mem::size_of::<*const u8>()));
                                                            {
                                                              let vec55 = (e.into_bytes()).into_boxed_slice();
                                                              let ptr55 = vec55.as_ptr().cast::<u8>();
                                                              let len55 = vec55.len();
                                                              ::core::mem::forget(vec55);
                                                              *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len55;
                                                              *base.add(0).cast::<*mut u8>() = ptr55.cast_mut();
                                                            }
                                                          }
                                                          *base.add(88+51*::core::mem::size_of::<*const u8>()).cast::<usize>() = len56;
                                                          *base.add(88+50*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result56;
                                                          match status33 {
                                                            Some(e) => {
                                                              *base.add(88+52*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                              *base.add(89+52*::core::mem::size_of::<*const u8>()).cast::<u8>() = (e.clone() as i32) as u8;
                                                            },
                                                            None => {
                                                              {
                                                                *base.add(88+52*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                              }
                                                            },
                                                          };match content_rating33 {
                                                            Some(e) => {
                                                              *base.add(88+53*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                              let vec57 = (e.into_bytes()).into_boxed_slice();
                                                              let ptr57 = vec57.as_ptr().cast::<u8>();
                                                              let len57 = vec57.len();
                                                              ::core::mem::forget(vec57);
                                                              *base.add(88+55*::core::mem::size_of::<*const u8>()).cast::<usize>() = len57;
                                                              *base.add(88+54*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr57.cast_mut();
                                                            },
                                                            None => {
                                                              {
                                                                *base.add(88+53*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                              }
                                                            },
                                                          };match url33 {
                                                            Some(e) => {
                                                              *base.add(88+56*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                              let vec58 = (e.into_bytes()).into_boxed_slice();
                                                              let ptr58 = vec58.as_ptr().cast::<u8>();
                                                              let len58 = vec58.len();
                                                              ::core::mem::forget(vec58);
                                                              *base.add(88+58*::core::mem::size_of::<*const u8>()).cast::<usize>() = len58;
                                                              *base.add(88+57*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr58.cast_mut();
                                                            },
                                                            None => {
                                                              {
                                                                *base.add(88+56*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                              }
                                                            },
                                                          };let vec62 = ids33;
                                                          let len62 = vec62.len();
                                                          let layout62 = _rt::alloc::Layout::from_size_align(vec62.len() * (4*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>()).unwrap();
                                                          let (result62, _cleanup62) = wit_bindgen::rt::Cleanup::new(layout62);if let Some(cleanup) = _cleanup62 { cleanup.forget(); }
                                                          for (i, e) in vec62.into_iter().enumerate() {
                                                            let base = result62.add(i * (4*::core::mem::size_of::<*const u8>()));
                                                            {
                                                              let super::super::bex::plugin::common::LinkedId{ source:source59, id:id59, } = e;
                                                              let vec60 = (source59.into_bytes()).into_boxed_slice();
                                                              let ptr60 = vec60.as_ptr().cast::<u8>();
                                                              let len60 = vec60.len();
                                                              ::core::mem::forget(vec60);
                                                              *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len60;
                                                              *base.add(0).cast::<*mut u8>() = ptr60.cast_mut();
                                                              let vec61 = (id59.into_bytes()).into_boxed_slice();
                                                              let ptr61 = vec61.as_ptr().cast::<u8>();
                                                              let len61 = vec61.len();
                                                              ::core::mem::forget(vec61);
                                                              *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len61;
                                                              *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr61.cast_mut();
                                                            }
                                                          }
                                                          *base.add(88+60*::core::mem::size_of::<*const u8>()).cast::<usize>() = len62;
                                                          *base.add(88+59*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result62;
                                                          let vec66 = extra33;
                                                          let len66 = vec66.len();
                                                          let layout66 = _rt::alloc::Layout::from_size_align(vec66.len() * (4*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>()).unwrap();
                                                          let (result66, _cleanup66) = wit_bindgen::rt::Cleanup::new(layout66);if let Some(cleanup) = _cleanup66 { cleanup.forget(); }
                                                          for (i, e) in vec66.into_iter().enumerate() {
                                                            let base = result66.add(i * (4*::core::mem::size_of::<*const u8>()));
                                                            {
                                                              let super::super::bex::plugin::common::Attr{ key:key63, value:value63, } = e;
                                                              let vec64 = (key63.into_bytes()).into_boxed_slice();
                                                              let ptr64 = vec64.as_ptr().cast::<u8>();
                                                              let len64 = vec64.len();
                                                              ::core::mem::forget(vec64);
                                                              *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len64;
                                                              *base.add(0).cast::<*mut u8>() = ptr64.cast_mut();
                                                              let vec65 = (value63.into_bytes()).into_boxed_slice();
                                                              let ptr65 = vec65.as_ptr().cast::<u8>();
                                                              let len65 = vec65.len();
                                                              ::core::mem::forget(vec65);
                                                              *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len65;
                                                              *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr65.cast_mut();
                                                            }
                                                          }
                                                          *base.add(88+62*::core::mem::size_of::<*const u8>()).cast::<usize>() = len66;
                                                          *base.add(88+61*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result66;
                                                        }
                                                      }
                                                      *ptr31.add(2*::core::mem::size_of::<*const u8>()).cast::<usize>() = len67;
                                                      *ptr31.add(::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result67;
                                                      let vec75 = categories32;
                                                      let len75 = vec75.len();
                                                      let layout75 = _rt::alloc::Layout::from_size_align(vec75.len() * (16+14*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>()).unwrap();
                                                      let (result75, _cleanup75) = wit_bindgen::rt::Cleanup::new(layout75);if let Some(cleanup) = _cleanup75 { cleanup.forget(); }
                                                      for (i, e) in vec75.into_iter().enumerate() {
                                                        let base = result75.add(i * (16+14*::core::mem::size_of::<*const u8>()));
                                                        {
                                                          let super::super::bex::plugin::common::CategoryLink{ id:id68, title:title68, subtitle:subtitle68, image:image68, } = e;
                                                          let vec69 = (id68.into_bytes()).into_boxed_slice();
                                                          let ptr69 = vec69.as_ptr().cast::<u8>();
                                                          let len69 = vec69.len();
                                                          ::core::mem::forget(vec69);
                                                          *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len69;
                                                          *base.add(0).cast::<*mut u8>() = ptr69.cast_mut();
                                                          let vec70 = (title68.into_bytes()).into_boxed_slice();
                                                          let ptr70 = vec70.as_ptr().cast::<u8>();
                                                          let len70 = vec70.len();
                                                          ::core::mem::forget(vec70);
                                                          *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len70;
                                                          *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr70.cast_mut();
                                                          match subtitle68 {
                                                            Some(e) => {
                                                              *base.add(4*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                              let vec71 = (e.into_bytes()).into_boxed_slice();
                                                              let ptr71 = vec71.as_ptr().cast::<u8>();
                                                              let len71 = vec71.len();
                                                              ::core::mem::forget(vec71);
                                                              *base.add(6*::core::mem::size_of::<*const u8>()).cast::<usize>() = len71;
                                                              *base.add(5*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr71.cast_mut();
                                                            },
                                                            None => {
                                                              {
                                                                *base.add(4*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                              }
                                                            },
                                                          };match image68 {
                                                            Some(e) => {
                                                              *base.add(7*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                              let super::super::bex::plugin::common::Image{ url:url72, layout:layout72, width:width72, height:height72, blurhash:blurhash72, } = e;
                                                              let vec73 = (url72.into_bytes()).into_boxed_slice();
                                                              let ptr73 = vec73.as_ptr().cast::<u8>();
                                                              let len73 = vec73.len();
                                                              ::core::mem::forget(vec73);
                                                              *base.add(9*::core::mem::size_of::<*const u8>()).cast::<usize>() = len73;
                                                              *base.add(8*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr73.cast_mut();
                                                              *base.add(10*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout72.clone() as i32) as u8;
                                                              match width72 {
                                                                Some(e) => {
                                                                  *base.add(4+10*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                  *base.add(8+10*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                },
                                                                None => {
                                                                  {
                                                                    *base.add(4+10*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                  }
                                                                },
                                                              };match height72 {
                                                                Some(e) => {
                                                                  *base.add(12+10*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                  *base.add(16+10*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                },
                                                                None => {
                                                                  {
                                                                    *base.add(12+10*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                  }
                                                                },
                                                              };match blurhash72 {
                                                                Some(e) => {
                                                                  *base.add(16+11*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                  let vec74 = (e.into_bytes()).into_boxed_slice();
                                                                  let ptr74 = vec74.as_ptr().cast::<u8>();
                                                                  let len74 = vec74.len();
                                                                  ::core::mem::forget(vec74);
                                                                  *base.add(16+13*::core::mem::size_of::<*const u8>()).cast::<usize>() = len74;
                                                                  *base.add(16+12*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr74.cast_mut();
                                                                },
                                                                None => {
                                                                  {
                                                                    *base.add(16+11*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                  }
                                                                },
                                                              };},
                                                              None => {
                                                                {
                                                                  *base.add(7*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                }
                                                              },
                                                            };}
                                                          }
                                                          *ptr31.add(4*::core::mem::size_of::<*const u8>()).cast::<usize>() = len75;
                                                          *ptr31.add(3*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result75;
                                                          match next_page32 {
                                                            Some(e) => {
                                                              *ptr31.add(5*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                              let vec76 = (e.into_bytes()).into_boxed_slice();
                                                              let ptr76 = vec76.as_ptr().cast::<u8>();
                                                              let len76 = vec76.len();
                                                              ::core::mem::forget(vec76);
                                                              *ptr31.add(7*::core::mem::size_of::<*const u8>()).cast::<usize>() = len76;
                                                              *ptr31.add(6*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr76.cast_mut();
                                                            },
                                                            None => {
                                                              {
                                                                *ptr31.add(5*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                              }
                                                            },
                                                          };} },
                                                          Err(e) => { {
                                                            *ptr31.add(0).cast::<u8>() = (1i32) as u8;
                                                            use super::super::bex::plugin::common::PluginError as V81;
                                                            match e {
                                                              V81::Network(e) => {
                                                                *ptr31.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                let vec77 = (e.into_bytes()).into_boxed_slice();
                                                                let ptr77 = vec77.as_ptr().cast::<u8>();
                                                                let len77 = vec77.len();
                                                                ::core::mem::forget(vec77);
                                                                *ptr31.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len77;
                                                                *ptr31.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr77.cast_mut();
                                                              },
                                                              V81::Parse(e) => {
                                                                *ptr31.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                let vec78 = (e.into_bytes()).into_boxed_slice();
                                                                let ptr78 = vec78.as_ptr().cast::<u8>();
                                                                let len78 = vec78.len();
                                                                ::core::mem::forget(vec78);
                                                                *ptr31.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len78;
                                                                *ptr31.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr78.cast_mut();
                                                              },
                                                              V81::NotFound=> {
                                                                {
                                                                  *ptr31.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (2i32) as u8;
                                                                }
                                                              }
                                                              V81::Unauthorized=> {
                                                                {
                                                                  *ptr31.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (3i32) as u8;
                                                                }
                                                              }
                                                              V81::Forbidden=> {
                                                                {
                                                                  *ptr31.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (4i32) as u8;
                                                                }
                                                              }
                                                              V81::RateLimited(e) => {
                                                                *ptr31.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (5i32) as u8;
                                                                match e {
                                                                  Some(e) => {
                                                                    *ptr31.add(2*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                    *ptr31.add(4+2*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                  },
                                                                  None => {
                                                                    {
                                                                      *ptr31.add(2*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                    }
                                                                  },
                                                                };},
                                                                V81::Timeout=> {
                                                                  {
                                                                    *ptr31.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (6i32) as u8;
                                                                  }
                                                                }
                                                                V81::Cancelled=> {
                                                                  {
                                                                    *ptr31.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (7i32) as u8;
                                                                  }
                                                                }
                                                                V81::Unsupported=> {
                                                                  {
                                                                    *ptr31.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (8i32) as u8;
                                                                  }
                                                                }
                                                                V81::InvalidInput(e) => {
                                                                  *ptr31.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (9i32) as u8;
                                                                  let vec79 = (e.into_bytes()).into_boxed_slice();
                                                                  let ptr79 = vec79.as_ptr().cast::<u8>();
                                                                  let len79 = vec79.len();
                                                                  ::core::mem::forget(vec79);
                                                                  *ptr31.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len79;
                                                                  *ptr31.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr79.cast_mut();
                                                                },
                                                                V81::Internal(e) => {
                                                                  *ptr31.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (10i32) as u8;
                                                                  let vec80 = (e.into_bytes()).into_boxed_slice();
                                                                  let ptr80 = vec80.as_ptr().cast::<u8>();
                                                                  let len80 = vec80.len();
                                                                  ::core::mem::forget(vec80);
                                                                  *ptr31.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len80;
                                                                  *ptr31.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr80.cast_mut();
                                                                },
                                                              }
                                                            } },
                                                          };ptr31
                                                        } }
                                                        #[doc(hidden)]
                                                        #[allow(non_snake_case)]
                                                        pub unsafe fn __post_return_search<T_: Guest>(arg0: *mut u8,) { unsafe {
                                                          let l0 = i32::from(*arg0.add(0).cast::<u8>());
                                                          match l0 {
                                                            0 => {
                                                              let l1 = *arg0.add(::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                              let l2 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                              let base72 = l1;
                                                              let len72 = l2;
                                                              for i in 0..len72 {
                                                                let base = base72.add(i * (88+63*::core::mem::size_of::<*const u8>()));
                                                                {
                                                                  let l3 = *base.add(0).cast::<*mut u8>();
                                                                  let l4 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                  _rt::cabi_dealloc(l3, l4, 1);
                                                                  let l5 = *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                  let l6 = *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                  _rt::cabi_dealloc(l5, l6, 1);
                                                                  let l7 = i32::from(*base.add(5*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                  match l7 {
                                                                    0 => (),
                                                                    _ => {
                                                                      let l8 = i32::from(*base.add(6*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                      match l8 {
                                                                        0 => (),
                                                                        _ => {
                                                                          let l9 = *base.add(7*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                          let l10 = *base.add(8*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                          _rt::cabi_dealloc(l9, l10, 1);
                                                                          let l11 = i32::from(*base.add(16+10*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                          match l11 {
                                                                            0 => (),
                                                                            _ => {
                                                                              let l12 = *base.add(16+11*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                              let l13 = *base.add(16+12*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                              _rt::cabi_dealloc(l12, l13, 1);
                                                                            },
                                                                          }
                                                                        },
                                                                      }
                                                                      let l14 = i32::from(*base.add(16+13*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                      match l14 {
                                                                        0 => (),
                                                                        _ => {
                                                                          let l15 = *base.add(16+14*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                          let l16 = *base.add(16+15*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                          _rt::cabi_dealloc(l15, l16, 1);
                                                                          let l17 = i32::from(*base.add(32+17*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                          match l17 {
                                                                            0 => (),
                                                                            _ => {
                                                                              let l18 = *base.add(32+18*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                              let l19 = *base.add(32+19*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                              _rt::cabi_dealloc(l18, l19, 1);
                                                                            },
                                                                          }
                                                                        },
                                                                      }
                                                                      let l20 = i32::from(*base.add(32+20*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                      match l20 {
                                                                        0 => (),
                                                                        _ => {
                                                                          let l21 = *base.add(32+21*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                          let l22 = *base.add(32+22*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                          _rt::cabi_dealloc(l21, l22, 1);
                                                                          let l23 = i32::from(*base.add(48+24*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                          match l23 {
                                                                            0 => (),
                                                                            _ => {
                                                                              let l24 = *base.add(48+25*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                              let l25 = *base.add(48+26*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                              _rt::cabi_dealloc(l24, l25, 1);
                                                                            },
                                                                          }
                                                                        },
                                                                      }
                                                                      let l26 = i32::from(*base.add(48+27*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                      match l26 {
                                                                        0 => (),
                                                                        _ => {
                                                                          let l27 = *base.add(48+28*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                          let l28 = *base.add(48+29*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                          _rt::cabi_dealloc(l27, l28, 1);
                                                                          let l29 = i32::from(*base.add(64+31*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                          match l29 {
                                                                            0 => (),
                                                                            _ => {
                                                                              let l30 = *base.add(64+32*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                              let l31 = *base.add(64+33*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                              _rt::cabi_dealloc(l30, l31, 1);
                                                                            },
                                                                          }
                                                                        },
                                                                      }
                                                                      let l32 = i32::from(*base.add(64+34*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                      match l32 {
                                                                        0 => (),
                                                                        _ => {
                                                                          let l33 = *base.add(64+35*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                          let l34 = *base.add(64+36*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                          _rt::cabi_dealloc(l33, l34, 1);
                                                                          let l35 = i32::from(*base.add(80+38*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                          match l35 {
                                                                            0 => (),
                                                                            _ => {
                                                                              let l36 = *base.add(80+39*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                              let l37 = *base.add(80+40*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                              _rt::cabi_dealloc(l36, l37, 1);
                                                                            },
                                                                          }
                                                                        },
                                                                      }
                                                                    },
                                                                  }
                                                                  let l38 = i32::from(*base.add(80+41*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                  match l38 {
                                                                    0 => (),
                                                                    _ => {
                                                                      let l39 = *base.add(80+42*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                      let l40 = *base.add(80+43*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                      _rt::cabi_dealloc(l39, l40, 1);
                                                                    },
                                                                  }
                                                                  let l41 = i32::from(*base.add(80+44*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                  match l41 {
                                                                    0 => (),
                                                                    _ => {
                                                                      let l42 = *base.add(80+45*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                      let l43 = *base.add(80+46*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                      _rt::cabi_dealloc(l42, l43, 1);
                                                                    },
                                                                  }
                                                                  let l44 = i32::from(*base.add(80+47*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                  match l44 {
                                                                    0 => (),
                                                                    _ => {
                                                                      let l45 = *base.add(80+48*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                      let l46 = *base.add(80+49*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                      _rt::cabi_dealloc(l45, l46, 1);
                                                                    },
                                                                  }
                                                                  let l47 = *base.add(88+50*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                  let l48 = *base.add(88+51*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                  let base51 = l47;
                                                                  let len51 = l48;
                                                                  for i in 0..len51 {
                                                                    let base = base51.add(i * (2*::core::mem::size_of::<*const u8>()));
                                                                    {
                                                                      let l49 = *base.add(0).cast::<*mut u8>();
                                                                      let l50 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                      _rt::cabi_dealloc(l49, l50, 1);
                                                                    }
                                                                  }
                                                                  _rt::cabi_dealloc(base51, len51 * (2*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                                                  let l52 = i32::from(*base.add(88+53*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                  match l52 {
                                                                    0 => (),
                                                                    _ => {
                                                                      let l53 = *base.add(88+54*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                      let l54 = *base.add(88+55*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                      _rt::cabi_dealloc(l53, l54, 1);
                                                                    },
                                                                  }
                                                                  let l55 = i32::from(*base.add(88+56*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                  match l55 {
                                                                    0 => (),
                                                                    _ => {
                                                                      let l56 = *base.add(88+57*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                      let l57 = *base.add(88+58*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                      _rt::cabi_dealloc(l56, l57, 1);
                                                                    },
                                                                  }
                                                                  let l58 = *base.add(88+59*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                  let l59 = *base.add(88+60*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                  let base64 = l58;
                                                                  let len64 = l59;
                                                                  for i in 0..len64 {
                                                                    let base = base64.add(i * (4*::core::mem::size_of::<*const u8>()));
                                                                    {
                                                                      let l60 = *base.add(0).cast::<*mut u8>();
                                                                      let l61 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                      _rt::cabi_dealloc(l60, l61, 1);
                                                                      let l62 = *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                      let l63 = *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                      _rt::cabi_dealloc(l62, l63, 1);
                                                                    }
                                                                  }
                                                                  _rt::cabi_dealloc(base64, len64 * (4*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                                                  let l65 = *base.add(88+61*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                  let l66 = *base.add(88+62*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                  let base71 = l65;
                                                                  let len71 = l66;
                                                                  for i in 0..len71 {
                                                                    let base = base71.add(i * (4*::core::mem::size_of::<*const u8>()));
                                                                    {
                                                                      let l67 = *base.add(0).cast::<*mut u8>();
                                                                      let l68 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                      _rt::cabi_dealloc(l67, l68, 1);
                                                                      let l69 = *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                      let l70 = *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                      _rt::cabi_dealloc(l69, l70, 1);
                                                                    }
                                                                  }
                                                                  _rt::cabi_dealloc(base71, len71 * (4*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                                                }
                                                              }
                                                              _rt::cabi_dealloc(base72, len72 * (88+63*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                                              let l73 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                              let l74 = *arg0.add(4*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                              let base88 = l73;
                                                              let len88 = l74;
                                                              for i in 0..len88 {
                                                                let base = base88.add(i * (16+14*::core::mem::size_of::<*const u8>()));
                                                                {
                                                                  let l75 = *base.add(0).cast::<*mut u8>();
                                                                  let l76 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                  _rt::cabi_dealloc(l75, l76, 1);
                                                                  let l77 = *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                  let l78 = *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                  _rt::cabi_dealloc(l77, l78, 1);
                                                                  let l79 = i32::from(*base.add(4*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                  match l79 {
                                                                    0 => (),
                                                                    _ => {
                                                                      let l80 = *base.add(5*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                      let l81 = *base.add(6*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                      _rt::cabi_dealloc(l80, l81, 1);
                                                                    },
                                                                  }
                                                                  let l82 = i32::from(*base.add(7*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                  match l82 {
                                                                    0 => (),
                                                                    _ => {
                                                                      let l83 = *base.add(8*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                      let l84 = *base.add(9*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                      _rt::cabi_dealloc(l83, l84, 1);
                                                                      let l85 = i32::from(*base.add(16+11*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                      match l85 {
                                                                        0 => (),
                                                                        _ => {
                                                                          let l86 = *base.add(16+12*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                          let l87 = *base.add(16+13*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                          _rt::cabi_dealloc(l86, l87, 1);
                                                                        },
                                                                      }
                                                                    },
                                                                  }
                                                                }
                                                              }
                                                              _rt::cabi_dealloc(base88, len88 * (16+14*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                                              let l89 = i32::from(*arg0.add(5*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                              match l89 {
                                                                0 => (),
                                                                _ => {
                                                                  let l90 = *arg0.add(6*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                  let l91 = *arg0.add(7*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                  _rt::cabi_dealloc(l90, l91, 1);
                                                                },
                                                              }
                                                            },
                                                            _ => {
                                                              let l92 = i32::from(*arg0.add(::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                              match l92 {
                                                                0 => {
                                                                  let l93 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                  let l94 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                  _rt::cabi_dealloc(l93, l94, 1);
                                                                },
                                                                1 => {
                                                                  let l95 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                  let l96 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                  _rt::cabi_dealloc(l95, l96, 1);
                                                                },
                                                                2 => (),
                                                                3 => (),
                                                                4 => (),
                                                                5 => (),
                                                                6 => (),
                                                                7 => (),
                                                                8 => (),
                                                                9 => {
                                                                  let l97 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                  let l98 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                  _rt::cabi_dealloc(l97, l98, 1);
                                                                },
                                                                _ => {
                                                                  let l99 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                  let l100 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                  _rt::cabi_dealloc(l99, l100, 1);
                                                                },
                                                              }
                                                            },
                                                          }
                                                        } }
                                                        #[doc(hidden)]
                                                        #[allow(non_snake_case, unused_unsafe)]
                                                        pub unsafe fn _export_get_info_cabi<T_: Guest>(arg0: *mut u8,arg1: usize,arg2: i32,arg3: *mut u8,arg4: usize,arg5: i32,arg6: *mut u8,arg7: usize,arg8: i32,arg9: *mut u8,arg10: usize,arg11: *mut u8,arg12: usize,) -> *mut u8 { unsafe {#[cfg(target_arch="wasm32")]
                                                        _rt::run_ctors_once();let result8 = {
                                                          let len0 = arg1;
                                                          let bytes0 = _rt::Vec::from_raw_parts(arg0.cast(), len0, len0);
                                                          let base6 = arg9;
                                                          let len6 = arg10;
                                                          let mut result6 = _rt::Vec::with_capacity(len6);
                                                          for i in 0..len6 {
                                                            let base = base6.add(i * (2*::core::mem::size_of::<*const u8>()));
                                                            let e6 = {
                                                              let l3 = *base.add(0).cast::<*mut u8>();
                                                              let l4 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                              let len5 = l4;
                                                              let bytes5 = _rt::Vec::from_raw_parts(l3.cast(), len5, len5);

                                                              _rt::string_lift(bytes5)
                                                            };
                                                            result6.push(e6);
                                                          }
                                                          _rt::cabi_dealloc(base6, len6 * (2*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                                          let len7 = arg12;
                                                          let bytes7 = _rt::Vec::from_raw_parts(arg11.cast(), len7, len7);
                                                          T_::get_info(super::super::bex::plugin::common::RequestContext{
                                                            request_id: _rt::string_lift(bytes0),
                                                            locale: match arg2 {
                                                              0 => None,
                                                              1 => {
                                                                let e = {
                                                                  let len1 = arg4;
                                                                  let bytes1 = _rt::Vec::from_raw_parts(arg3.cast(), len1, len1);

                                                                  _rt::string_lift(bytes1)
                                                                };
                                                                Some(e)
                                                              }
                                                              _ => _rt::invalid_enum_discriminant(),
                                                            },
                                                            region: match arg5 {
                                                              0 => None,
                                                              1 => {
                                                                let e = {
                                                                  let len2 = arg7;
                                                                  let bytes2 = _rt::Vec::from_raw_parts(arg6.cast(), len2, len2);

                                                                  _rt::string_lift(bytes2)
                                                                };
                                                                Some(e)
                                                              }
                                                              _ => _rt::invalid_enum_discriminant(),
                                                            },
                                                            safe_mode: _rt::bool_lift(arg8 as u8),
                                                            hints: result6,
                                                          }, _rt::string_lift(bytes7))
                                                        };
                                                        let ptr9 = (&raw mut _RET_AREA.0).cast::<u8>();
                                                        match result8 {
                                                          Ok(e) => { {
                                                            *ptr9.add(0).cast::<u8>() = (0i32) as u8;
                                                            let super::super::bex::plugin::common::MediaInfo{ id:id10, title:title10, kind:kind10, images:images10, original_title:original_title10, description:description10, score:score10, scored_by:scored_by10, year:year10, release_date:release_date10, genres:genres10, tags:tags10, status:status10, content_rating:content_rating10, seasons:seasons10, cast:cast10, crew:crew10, runtime_minutes:runtime_minutes10, trailer_url:trailer_url10, ids:ids10, studio:studio10, country:country10, language:language10, url:url10, extra:extra10, } = e;
                                                            let vec11 = (id10.into_bytes()).into_boxed_slice();
                                                            let ptr11 = vec11.as_ptr().cast::<u8>();
                                                            let len11 = vec11.len();
                                                            ::core::mem::forget(vec11);
                                                            *ptr9.add(8+1*::core::mem::size_of::<*const u8>()).cast::<usize>() = len11;
                                                            *ptr9.add(8).cast::<*mut u8>() = ptr11.cast_mut();
                                                            let vec12 = (title10.into_bytes()).into_boxed_slice();
                                                            let ptr12 = vec12.as_ptr().cast::<u8>();
                                                            let len12 = vec12.len();
                                                            ::core::mem::forget(vec12);
                                                            *ptr9.add(8+3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len12;
                                                            *ptr9.add(8+2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr12.cast_mut();
                                                            *ptr9.add(8+4*::core::mem::size_of::<*const u8>()).cast::<u8>() = (kind10.clone() as i32) as u8;
                                                            match images10 {
                                                              Some(e) => {
                                                                *ptr9.add(8+5*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                let super::super::bex::plugin::common::ImageSet{ low:low13, medium:medium13, high:high13, backdrop:backdrop13, logo:logo13, } = e;
                                                                match low13 {
                                                                  Some(e) => {
                                                                    *ptr9.add(8+6*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                    let super::super::bex::plugin::common::Image{ url:url14, layout:layout14, width:width14, height:height14, blurhash:blurhash14, } = e;
                                                                    let vec15 = (url14.into_bytes()).into_boxed_slice();
                                                                    let ptr15 = vec15.as_ptr().cast::<u8>();
                                                                    let len15 = vec15.len();
                                                                    ::core::mem::forget(vec15);
                                                                    *ptr9.add(8+8*::core::mem::size_of::<*const u8>()).cast::<usize>() = len15;
                                                                    *ptr9.add(8+7*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr15.cast_mut();
                                                                    *ptr9.add(8+9*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout14.clone() as i32) as u8;
                                                                    match width14 {
                                                                      Some(e) => {
                                                                        *ptr9.add(12+9*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                        *ptr9.add(16+9*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                      },
                                                                      None => {
                                                                        {
                                                                          *ptr9.add(12+9*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                        }
                                                                      },
                                                                    };match height14 {
                                                                      Some(e) => {
                                                                        *ptr9.add(20+9*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                        *ptr9.add(24+9*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                      },
                                                                      None => {
                                                                        {
                                                                          *ptr9.add(20+9*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                        }
                                                                      },
                                                                    };match blurhash14 {
                                                                      Some(e) => {
                                                                        *ptr9.add(24+10*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                        let vec16 = (e.into_bytes()).into_boxed_slice();
                                                                        let ptr16 = vec16.as_ptr().cast::<u8>();
                                                                        let len16 = vec16.len();
                                                                        ::core::mem::forget(vec16);
                                                                        *ptr9.add(24+12*::core::mem::size_of::<*const u8>()).cast::<usize>() = len16;
                                                                        *ptr9.add(24+11*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr16.cast_mut();
                                                                      },
                                                                      None => {
                                                                        {
                                                                          *ptr9.add(24+10*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                        }
                                                                      },
                                                                    };},
                                                                    None => {
                                                                      {
                                                                        *ptr9.add(8+6*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                      }
                                                                    },
                                                                  };match medium13 {
                                                                    Some(e) => {
                                                                      *ptr9.add(24+13*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                      let super::super::bex::plugin::common::Image{ url:url17, layout:layout17, width:width17, height:height17, blurhash:blurhash17, } = e;
                                                                      let vec18 = (url17.into_bytes()).into_boxed_slice();
                                                                      let ptr18 = vec18.as_ptr().cast::<u8>();
                                                                      let len18 = vec18.len();
                                                                      ::core::mem::forget(vec18);
                                                                      *ptr9.add(24+15*::core::mem::size_of::<*const u8>()).cast::<usize>() = len18;
                                                                      *ptr9.add(24+14*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr18.cast_mut();
                                                                      *ptr9.add(24+16*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout17.clone() as i32) as u8;
                                                                      match width17 {
                                                                        Some(e) => {
                                                                          *ptr9.add(28+16*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                          *ptr9.add(32+16*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                        },
                                                                        None => {
                                                                          {
                                                                            *ptr9.add(28+16*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                          }
                                                                        },
                                                                      };match height17 {
                                                                        Some(e) => {
                                                                          *ptr9.add(36+16*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                          *ptr9.add(40+16*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                        },
                                                                        None => {
                                                                          {
                                                                            *ptr9.add(36+16*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                          }
                                                                        },
                                                                      };match blurhash17 {
                                                                        Some(e) => {
                                                                          *ptr9.add(40+17*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                          let vec19 = (e.into_bytes()).into_boxed_slice();
                                                                          let ptr19 = vec19.as_ptr().cast::<u8>();
                                                                          let len19 = vec19.len();
                                                                          ::core::mem::forget(vec19);
                                                                          *ptr9.add(40+19*::core::mem::size_of::<*const u8>()).cast::<usize>() = len19;
                                                                          *ptr9.add(40+18*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr19.cast_mut();
                                                                        },
                                                                        None => {
                                                                          {
                                                                            *ptr9.add(40+17*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                          }
                                                                        },
                                                                      };},
                                                                      None => {
                                                                        {
                                                                          *ptr9.add(24+13*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                        }
                                                                      },
                                                                    };match high13 {
                                                                      Some(e) => {
                                                                        *ptr9.add(40+20*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                        let super::super::bex::plugin::common::Image{ url:url20, layout:layout20, width:width20, height:height20, blurhash:blurhash20, } = e;
                                                                        let vec21 = (url20.into_bytes()).into_boxed_slice();
                                                                        let ptr21 = vec21.as_ptr().cast::<u8>();
                                                                        let len21 = vec21.len();
                                                                        ::core::mem::forget(vec21);
                                                                        *ptr9.add(40+22*::core::mem::size_of::<*const u8>()).cast::<usize>() = len21;
                                                                        *ptr9.add(40+21*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr21.cast_mut();
                                                                        *ptr9.add(40+23*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout20.clone() as i32) as u8;
                                                                        match width20 {
                                                                          Some(e) => {
                                                                            *ptr9.add(44+23*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                            *ptr9.add(48+23*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                          },
                                                                          None => {
                                                                            {
                                                                              *ptr9.add(44+23*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                            }
                                                                          },
                                                                        };match height20 {
                                                                          Some(e) => {
                                                                            *ptr9.add(52+23*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                            *ptr9.add(56+23*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                          },
                                                                          None => {
                                                                            {
                                                                              *ptr9.add(52+23*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                            }
                                                                          },
                                                                        };match blurhash20 {
                                                                          Some(e) => {
                                                                            *ptr9.add(56+24*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                            let vec22 = (e.into_bytes()).into_boxed_slice();
                                                                            let ptr22 = vec22.as_ptr().cast::<u8>();
                                                                            let len22 = vec22.len();
                                                                            ::core::mem::forget(vec22);
                                                                            *ptr9.add(56+26*::core::mem::size_of::<*const u8>()).cast::<usize>() = len22;
                                                                            *ptr9.add(56+25*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr22.cast_mut();
                                                                          },
                                                                          None => {
                                                                            {
                                                                              *ptr9.add(56+24*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                            }
                                                                          },
                                                                        };},
                                                                        None => {
                                                                          {
                                                                            *ptr9.add(40+20*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                          }
                                                                        },
                                                                      };match backdrop13 {
                                                                        Some(e) => {
                                                                          *ptr9.add(56+27*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                          let super::super::bex::plugin::common::Image{ url:url23, layout:layout23, width:width23, height:height23, blurhash:blurhash23, } = e;
                                                                          let vec24 = (url23.into_bytes()).into_boxed_slice();
                                                                          let ptr24 = vec24.as_ptr().cast::<u8>();
                                                                          let len24 = vec24.len();
                                                                          ::core::mem::forget(vec24);
                                                                          *ptr9.add(56+29*::core::mem::size_of::<*const u8>()).cast::<usize>() = len24;
                                                                          *ptr9.add(56+28*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr24.cast_mut();
                                                                          *ptr9.add(56+30*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout23.clone() as i32) as u8;
                                                                          match width23 {
                                                                            Some(e) => {
                                                                              *ptr9.add(60+30*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                              *ptr9.add(64+30*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                            },
                                                                            None => {
                                                                              {
                                                                                *ptr9.add(60+30*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                              }
                                                                            },
                                                                          };match height23 {
                                                                            Some(e) => {
                                                                              *ptr9.add(68+30*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                              *ptr9.add(72+30*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                            },
                                                                            None => {
                                                                              {
                                                                                *ptr9.add(68+30*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                              }
                                                                            },
                                                                          };match blurhash23 {
                                                                            Some(e) => {
                                                                              *ptr9.add(72+31*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                              let vec25 = (e.into_bytes()).into_boxed_slice();
                                                                              let ptr25 = vec25.as_ptr().cast::<u8>();
                                                                              let len25 = vec25.len();
                                                                              ::core::mem::forget(vec25);
                                                                              *ptr9.add(72+33*::core::mem::size_of::<*const u8>()).cast::<usize>() = len25;
                                                                              *ptr9.add(72+32*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr25.cast_mut();
                                                                            },
                                                                            None => {
                                                                              {
                                                                                *ptr9.add(72+31*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                              }
                                                                            },
                                                                          };},
                                                                          None => {
                                                                            {
                                                                              *ptr9.add(56+27*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                            }
                                                                          },
                                                                        };match logo13 {
                                                                          Some(e) => {
                                                                            *ptr9.add(72+34*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                            let super::super::bex::plugin::common::Image{ url:url26, layout:layout26, width:width26, height:height26, blurhash:blurhash26, } = e;
                                                                            let vec27 = (url26.into_bytes()).into_boxed_slice();
                                                                            let ptr27 = vec27.as_ptr().cast::<u8>();
                                                                            let len27 = vec27.len();
                                                                            ::core::mem::forget(vec27);
                                                                            *ptr9.add(72+36*::core::mem::size_of::<*const u8>()).cast::<usize>() = len27;
                                                                            *ptr9.add(72+35*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr27.cast_mut();
                                                                            *ptr9.add(72+37*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout26.clone() as i32) as u8;
                                                                            match width26 {
                                                                              Some(e) => {
                                                                                *ptr9.add(76+37*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                *ptr9.add(80+37*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                              },
                                                                              None => {
                                                                                {
                                                                                  *ptr9.add(76+37*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                }
                                                                              },
                                                                            };match height26 {
                                                                              Some(e) => {
                                                                                *ptr9.add(84+37*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                *ptr9.add(88+37*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                              },
                                                                              None => {
                                                                                {
                                                                                  *ptr9.add(84+37*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                }
                                                                              },
                                                                            };match blurhash26 {
                                                                              Some(e) => {
                                                                                *ptr9.add(88+38*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                let vec28 = (e.into_bytes()).into_boxed_slice();
                                                                                let ptr28 = vec28.as_ptr().cast::<u8>();
                                                                                let len28 = vec28.len();
                                                                                ::core::mem::forget(vec28);
                                                                                *ptr9.add(88+40*::core::mem::size_of::<*const u8>()).cast::<usize>() = len28;
                                                                                *ptr9.add(88+39*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr28.cast_mut();
                                                                              },
                                                                              None => {
                                                                                {
                                                                                  *ptr9.add(88+38*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                }
                                                                              },
                                                                            };},
                                                                            None => {
                                                                              {
                                                                                *ptr9.add(72+34*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                              }
                                                                            },
                                                                          };},
                                                                          None => {
                                                                            {
                                                                              *ptr9.add(8+5*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                            }
                                                                          },
                                                                        };match original_title10 {
                                                                          Some(e) => {
                                                                            *ptr9.add(88+41*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                            let vec29 = (e.into_bytes()).into_boxed_slice();
                                                                            let ptr29 = vec29.as_ptr().cast::<u8>();
                                                                            let len29 = vec29.len();
                                                                            ::core::mem::forget(vec29);
                                                                            *ptr9.add(88+43*::core::mem::size_of::<*const u8>()).cast::<usize>() = len29;
                                                                            *ptr9.add(88+42*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr29.cast_mut();
                                                                          },
                                                                          None => {
                                                                            {
                                                                              *ptr9.add(88+41*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                            }
                                                                          },
                                                                        };match description10 {
                                                                          Some(e) => {
                                                                            *ptr9.add(88+44*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                            let vec30 = (e.into_bytes()).into_boxed_slice();
                                                                            let ptr30 = vec30.as_ptr().cast::<u8>();
                                                                            let len30 = vec30.len();
                                                                            ::core::mem::forget(vec30);
                                                                            *ptr9.add(88+46*::core::mem::size_of::<*const u8>()).cast::<usize>() = len30;
                                                                            *ptr9.add(88+45*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr30.cast_mut();
                                                                          },
                                                                          None => {
                                                                            {
                                                                              *ptr9.add(88+44*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                            }
                                                                          },
                                                                        };match score10 {
                                                                          Some(e) => {
                                                                            *ptr9.add(88+47*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                            *ptr9.add(92+47*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                          },
                                                                          None => {
                                                                            {
                                                                              *ptr9.add(88+47*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                            }
                                                                          },
                                                                        };match scored_by10 {
                                                                          Some(e) => {
                                                                            *ptr9.add(104+46*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                            *ptr9.add(112+46*::core::mem::size_of::<*const u8>()).cast::<i64>() = _rt::as_i64(e);
                                                                          },
                                                                          None => {
                                                                            {
                                                                              *ptr9.add(104+46*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                            }
                                                                          },
                                                                        };match year10 {
                                                                          Some(e) => {
                                                                            *ptr9.add(120+46*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                            let vec31 = (e.into_bytes()).into_boxed_slice();
                                                                            let ptr31 = vec31.as_ptr().cast::<u8>();
                                                                            let len31 = vec31.len();
                                                                            ::core::mem::forget(vec31);
                                                                            *ptr9.add(120+48*::core::mem::size_of::<*const u8>()).cast::<usize>() = len31;
                                                                            *ptr9.add(120+47*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr31.cast_mut();
                                                                          },
                                                                          None => {
                                                                            {
                                                                              *ptr9.add(120+46*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                            }
                                                                          },
                                                                        };match release_date10 {
                                                                          Some(e) => {
                                                                            *ptr9.add(120+49*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                            let vec32 = (e.into_bytes()).into_boxed_slice();
                                                                            let ptr32 = vec32.as_ptr().cast::<u8>();
                                                                            let len32 = vec32.len();
                                                                            ::core::mem::forget(vec32);
                                                                            *ptr9.add(120+51*::core::mem::size_of::<*const u8>()).cast::<usize>() = len32;
                                                                            *ptr9.add(120+50*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr32.cast_mut();
                                                                          },
                                                                          None => {
                                                                            {
                                                                              *ptr9.add(120+49*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                            }
                                                                          },
                                                                        };let vec34 = genres10;
                                                                        let len34 = vec34.len();
                                                                        let layout34 = _rt::alloc::Layout::from_size_align(vec34.len() * (2*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>()).unwrap();
                                                                        let (result34, _cleanup34) = wit_bindgen::rt::Cleanup::new(layout34);if let Some(cleanup) = _cleanup34 { cleanup.forget(); }
                                                                        for (i, e) in vec34.into_iter().enumerate() {
                                                                          let base = result34.add(i * (2*::core::mem::size_of::<*const u8>()));
                                                                          {
                                                                            let vec33 = (e.into_bytes()).into_boxed_slice();
                                                                            let ptr33 = vec33.as_ptr().cast::<u8>();
                                                                            let len33 = vec33.len();
                                                                            ::core::mem::forget(vec33);
                                                                            *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len33;
                                                                            *base.add(0).cast::<*mut u8>() = ptr33.cast_mut();
                                                                          }
                                                                        }
                                                                        *ptr9.add(120+53*::core::mem::size_of::<*const u8>()).cast::<usize>() = len34;
                                                                        *ptr9.add(120+52*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result34;
                                                                        let vec36 = tags10;
                                                                        let len36 = vec36.len();
                                                                        let layout36 = _rt::alloc::Layout::from_size_align(vec36.len() * (2*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>()).unwrap();
                                                                        let (result36, _cleanup36) = wit_bindgen::rt::Cleanup::new(layout36);if let Some(cleanup) = _cleanup36 { cleanup.forget(); }
                                                                        for (i, e) in vec36.into_iter().enumerate() {
                                                                          let base = result36.add(i * (2*::core::mem::size_of::<*const u8>()));
                                                                          {
                                                                            let vec35 = (e.into_bytes()).into_boxed_slice();
                                                                            let ptr35 = vec35.as_ptr().cast::<u8>();
                                                                            let len35 = vec35.len();
                                                                            ::core::mem::forget(vec35);
                                                                            *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len35;
                                                                            *base.add(0).cast::<*mut u8>() = ptr35.cast_mut();
                                                                          }
                                                                        }
                                                                        *ptr9.add(120+55*::core::mem::size_of::<*const u8>()).cast::<usize>() = len36;
                                                                        *ptr9.add(120+54*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result36;
                                                                        match status10 {
                                                                          Some(e) => {
                                                                            *ptr9.add(120+56*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                            *ptr9.add(121+56*::core::mem::size_of::<*const u8>()).cast::<u8>() = (e.clone() as i32) as u8;
                                                                          },
                                                                          None => {
                                                                            {
                                                                              *ptr9.add(120+56*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                            }
                                                                          },
                                                                        };match content_rating10 {
                                                                          Some(e) => {
                                                                            *ptr9.add(120+57*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                            let vec37 = (e.into_bytes()).into_boxed_slice();
                                                                            let ptr37 = vec37.as_ptr().cast::<u8>();
                                                                            let len37 = vec37.len();
                                                                            ::core::mem::forget(vec37);
                                                                            *ptr9.add(120+59*::core::mem::size_of::<*const u8>()).cast::<usize>() = len37;
                                                                            *ptr9.add(120+58*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr37.cast_mut();
                                                                          },
                                                                          None => {
                                                                            {
                                                                              *ptr9.add(120+57*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                            }
                                                                          },
                                                                        };let vec70 = seasons10;
                                                                        let len70 = vec70.len();
                                                                        let layout70 = _rt::alloc::Layout::from_size_align(vec70.len() * (24+6*::core::mem::size_of::<*const u8>()), 8).unwrap();
                                                                        let (result70, _cleanup70) = wit_bindgen::rt::Cleanup::new(layout70);if let Some(cleanup) = _cleanup70 { cleanup.forget(); }
                                                                        for (i, e) in vec70.into_iter().enumerate() {
                                                                          let base = result70.add(i * (24+6*::core::mem::size_of::<*const u8>()));
                                                                          {
                                                                            let super::super::bex::plugin::common::Season{ id:id38, title:title38, number:number38, year:year38, episodes:episodes38, } = e;
                                                                            let vec39 = (id38.into_bytes()).into_boxed_slice();
                                                                            let ptr39 = vec39.as_ptr().cast::<u8>();
                                                                            let len39 = vec39.len();
                                                                            ::core::mem::forget(vec39);
                                                                            *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len39;
                                                                            *base.add(0).cast::<*mut u8>() = ptr39.cast_mut();
                                                                            let vec40 = (title38.into_bytes()).into_boxed_slice();
                                                                            let ptr40 = vec40.as_ptr().cast::<u8>();
                                                                            let len40 = vec40.len();
                                                                            ::core::mem::forget(vec40);
                                                                            *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len40;
                                                                            *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr40.cast_mut();
                                                                            match number38 {
                                                                              Some(e) => {
                                                                                *base.add(4*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                *base.add(8+4*::core::mem::size_of::<*const u8>()).cast::<f64>() = _rt::as_f64(e);
                                                                              },
                                                                              None => {
                                                                                {
                                                                                  *base.add(4*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                }
                                                                              },
                                                                            };match year38 {
                                                                              Some(e) => {
                                                                                *base.add(16+4*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                *base.add(20+4*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                              },
                                                                              None => {
                                                                                {
                                                                                  *base.add(16+4*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                }
                                                                              },
                                                                            };let vec69 = episodes38;
                                                                            let len69 = vec69.len();
                                                                            let layout69 = _rt::alloc::Layout::from_size_align(vec69.len() * (128+52*::core::mem::size_of::<*const u8>()), 8).unwrap();
                                                                            let (result69, _cleanup69) = wit_bindgen::rt::Cleanup::new(layout69);if let Some(cleanup) = _cleanup69 { cleanup.forget(); }
                                                                            for (i, e) in vec69.into_iter().enumerate() {
                                                                              let base = result69.add(i * (128+52*::core::mem::size_of::<*const u8>()));
                                                                              {
                                                                                let super::super::bex::plugin::common::Episode{ id:id41, title:title41, number:number41, season:season41, images:images41, description:description41, released:released41, score:score41, url:url41, tags:tags41, extra:extra41, } = e;
                                                                                let vec42 = (id41.into_bytes()).into_boxed_slice();
                                                                                let ptr42 = vec42.as_ptr().cast::<u8>();
                                                                                let len42 = vec42.len();
                                                                                ::core::mem::forget(vec42);
                                                                                *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len42;
                                                                                *base.add(0).cast::<*mut u8>() = ptr42.cast_mut();
                                                                                let vec43 = (title41.into_bytes()).into_boxed_slice();
                                                                                let ptr43 = vec43.as_ptr().cast::<u8>();
                                                                                let len43 = vec43.len();
                                                                                ::core::mem::forget(vec43);
                                                                                *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len43;
                                                                                *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr43.cast_mut();
                                                                                match number41 {
                                                                                  Some(e) => {
                                                                                    *base.add(4*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                    *base.add(8+4*::core::mem::size_of::<*const u8>()).cast::<f64>() = _rt::as_f64(e);
                                                                                  },
                                                                                  None => {
                                                                                    {
                                                                                      *base.add(4*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                    }
                                                                                  },
                                                                                };match season41 {
                                                                                  Some(e) => {
                                                                                    *base.add(16+4*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                    *base.add(24+4*::core::mem::size_of::<*const u8>()).cast::<f64>() = _rt::as_f64(e);
                                                                                  },
                                                                                  None => {
                                                                                    {
                                                                                      *base.add(16+4*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                    }
                                                                                  },
                                                                                };match images41 {
                                                                                  Some(e) => {
                                                                                    *base.add(32+4*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                    let super::super::bex::plugin::common::ImageSet{ low:low44, medium:medium44, high:high44, backdrop:backdrop44, logo:logo44, } = e;
                                                                                    match low44 {
                                                                                      Some(e) => {
                                                                                        *base.add(32+5*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                        let super::super::bex::plugin::common::Image{ url:url45, layout:layout45, width:width45, height:height45, blurhash:blurhash45, } = e;
                                                                                        let vec46 = (url45.into_bytes()).into_boxed_slice();
                                                                                        let ptr46 = vec46.as_ptr().cast::<u8>();
                                                                                        let len46 = vec46.len();
                                                                                        ::core::mem::forget(vec46);
                                                                                        *base.add(32+7*::core::mem::size_of::<*const u8>()).cast::<usize>() = len46;
                                                                                        *base.add(32+6*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr46.cast_mut();
                                                                                        *base.add(32+8*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout45.clone() as i32) as u8;
                                                                                        match width45 {
                                                                                          Some(e) => {
                                                                                            *base.add(36+8*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                            *base.add(40+8*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                          },
                                                                                          None => {
                                                                                            {
                                                                                              *base.add(36+8*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                            }
                                                                                          },
                                                                                        };match height45 {
                                                                                          Some(e) => {
                                                                                            *base.add(44+8*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                            *base.add(48+8*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                          },
                                                                                          None => {
                                                                                            {
                                                                                              *base.add(44+8*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                            }
                                                                                          },
                                                                                        };match blurhash45 {
                                                                                          Some(e) => {
                                                                                            *base.add(48+9*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                            let vec47 = (e.into_bytes()).into_boxed_slice();
                                                                                            let ptr47 = vec47.as_ptr().cast::<u8>();
                                                                                            let len47 = vec47.len();
                                                                                            ::core::mem::forget(vec47);
                                                                                            *base.add(48+11*::core::mem::size_of::<*const u8>()).cast::<usize>() = len47;
                                                                                            *base.add(48+10*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr47.cast_mut();
                                                                                          },
                                                                                          None => {
                                                                                            {
                                                                                              *base.add(48+9*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                            }
                                                                                          },
                                                                                        };},
                                                                                        None => {
                                                                                          {
                                                                                            *base.add(32+5*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                          }
                                                                                        },
                                                                                      };match medium44 {
                                                                                        Some(e) => {
                                                                                          *base.add(48+12*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                          let super::super::bex::plugin::common::Image{ url:url48, layout:layout48, width:width48, height:height48, blurhash:blurhash48, } = e;
                                                                                          let vec49 = (url48.into_bytes()).into_boxed_slice();
                                                                                          let ptr49 = vec49.as_ptr().cast::<u8>();
                                                                                          let len49 = vec49.len();
                                                                                          ::core::mem::forget(vec49);
                                                                                          *base.add(48+14*::core::mem::size_of::<*const u8>()).cast::<usize>() = len49;
                                                                                          *base.add(48+13*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr49.cast_mut();
                                                                                          *base.add(48+15*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout48.clone() as i32) as u8;
                                                                                          match width48 {
                                                                                            Some(e) => {
                                                                                              *base.add(52+15*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                              *base.add(56+15*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                            },
                                                                                            None => {
                                                                                              {
                                                                                                *base.add(52+15*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                              }
                                                                                            },
                                                                                          };match height48 {
                                                                                            Some(e) => {
                                                                                              *base.add(60+15*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                              *base.add(64+15*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                            },
                                                                                            None => {
                                                                                              {
                                                                                                *base.add(60+15*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                              }
                                                                                            },
                                                                                          };match blurhash48 {
                                                                                            Some(e) => {
                                                                                              *base.add(64+16*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                              let vec50 = (e.into_bytes()).into_boxed_slice();
                                                                                              let ptr50 = vec50.as_ptr().cast::<u8>();
                                                                                              let len50 = vec50.len();
                                                                                              ::core::mem::forget(vec50);
                                                                                              *base.add(64+18*::core::mem::size_of::<*const u8>()).cast::<usize>() = len50;
                                                                                              *base.add(64+17*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr50.cast_mut();
                                                                                            },
                                                                                            None => {
                                                                                              {
                                                                                                *base.add(64+16*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                              }
                                                                                            },
                                                                                          };},
                                                                                          None => {
                                                                                            {
                                                                                              *base.add(48+12*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                            }
                                                                                          },
                                                                                        };match high44 {
                                                                                          Some(e) => {
                                                                                            *base.add(64+19*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                            let super::super::bex::plugin::common::Image{ url:url51, layout:layout51, width:width51, height:height51, blurhash:blurhash51, } = e;
                                                                                            let vec52 = (url51.into_bytes()).into_boxed_slice();
                                                                                            let ptr52 = vec52.as_ptr().cast::<u8>();
                                                                                            let len52 = vec52.len();
                                                                                            ::core::mem::forget(vec52);
                                                                                            *base.add(64+21*::core::mem::size_of::<*const u8>()).cast::<usize>() = len52;
                                                                                            *base.add(64+20*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr52.cast_mut();
                                                                                            *base.add(64+22*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout51.clone() as i32) as u8;
                                                                                            match width51 {
                                                                                              Some(e) => {
                                                                                                *base.add(68+22*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                *base.add(72+22*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                              },
                                                                                              None => {
                                                                                                {
                                                                                                  *base.add(68+22*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                }
                                                                                              },
                                                                                            };match height51 {
                                                                                              Some(e) => {
                                                                                                *base.add(76+22*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                *base.add(80+22*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                              },
                                                                                              None => {
                                                                                                {
                                                                                                  *base.add(76+22*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                }
                                                                                              },
                                                                                            };match blurhash51 {
                                                                                              Some(e) => {
                                                                                                *base.add(80+23*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                let vec53 = (e.into_bytes()).into_boxed_slice();
                                                                                                let ptr53 = vec53.as_ptr().cast::<u8>();
                                                                                                let len53 = vec53.len();
                                                                                                ::core::mem::forget(vec53);
                                                                                                *base.add(80+25*::core::mem::size_of::<*const u8>()).cast::<usize>() = len53;
                                                                                                *base.add(80+24*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr53.cast_mut();
                                                                                              },
                                                                                              None => {
                                                                                                {
                                                                                                  *base.add(80+23*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                }
                                                                                              },
                                                                                            };},
                                                                                            None => {
                                                                                              {
                                                                                                *base.add(64+19*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                              }
                                                                                            },
                                                                                          };match backdrop44 {
                                                                                            Some(e) => {
                                                                                              *base.add(80+26*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                              let super::super::bex::plugin::common::Image{ url:url54, layout:layout54, width:width54, height:height54, blurhash:blurhash54, } = e;
                                                                                              let vec55 = (url54.into_bytes()).into_boxed_slice();
                                                                                              let ptr55 = vec55.as_ptr().cast::<u8>();
                                                                                              let len55 = vec55.len();
                                                                                              ::core::mem::forget(vec55);
                                                                                              *base.add(80+28*::core::mem::size_of::<*const u8>()).cast::<usize>() = len55;
                                                                                              *base.add(80+27*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr55.cast_mut();
                                                                                              *base.add(80+29*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout54.clone() as i32) as u8;
                                                                                              match width54 {
                                                                                                Some(e) => {
                                                                                                  *base.add(84+29*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                  *base.add(88+29*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                },
                                                                                                None => {
                                                                                                  {
                                                                                                    *base.add(84+29*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                  }
                                                                                                },
                                                                                              };match height54 {
                                                                                                Some(e) => {
                                                                                                  *base.add(92+29*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                  *base.add(96+29*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                },
                                                                                                None => {
                                                                                                  {
                                                                                                    *base.add(92+29*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                  }
                                                                                                },
                                                                                              };match blurhash54 {
                                                                                                Some(e) => {
                                                                                                  *base.add(96+30*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                  let vec56 = (e.into_bytes()).into_boxed_slice();
                                                                                                  let ptr56 = vec56.as_ptr().cast::<u8>();
                                                                                                  let len56 = vec56.len();
                                                                                                  ::core::mem::forget(vec56);
                                                                                                  *base.add(96+32*::core::mem::size_of::<*const u8>()).cast::<usize>() = len56;
                                                                                                  *base.add(96+31*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr56.cast_mut();
                                                                                                },
                                                                                                None => {
                                                                                                  {
                                                                                                    *base.add(96+30*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                  }
                                                                                                },
                                                                                              };},
                                                                                              None => {
                                                                                                {
                                                                                                  *base.add(80+26*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                }
                                                                                              },
                                                                                            };match logo44 {
                                                                                              Some(e) => {
                                                                                                *base.add(96+33*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                let super::super::bex::plugin::common::Image{ url:url57, layout:layout57, width:width57, height:height57, blurhash:blurhash57, } = e;
                                                                                                let vec58 = (url57.into_bytes()).into_boxed_slice();
                                                                                                let ptr58 = vec58.as_ptr().cast::<u8>();
                                                                                                let len58 = vec58.len();
                                                                                                ::core::mem::forget(vec58);
                                                                                                *base.add(96+35*::core::mem::size_of::<*const u8>()).cast::<usize>() = len58;
                                                                                                *base.add(96+34*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr58.cast_mut();
                                                                                                *base.add(96+36*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout57.clone() as i32) as u8;
                                                                                                match width57 {
                                                                                                  Some(e) => {
                                                                                                    *base.add(100+36*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                    *base.add(104+36*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                  },
                                                                                                  None => {
                                                                                                    {
                                                                                                      *base.add(100+36*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                    }
                                                                                                  },
                                                                                                };match height57 {
                                                                                                  Some(e) => {
                                                                                                    *base.add(108+36*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                    *base.add(112+36*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                  },
                                                                                                  None => {
                                                                                                    {
                                                                                                      *base.add(108+36*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                    }
                                                                                                  },
                                                                                                };match blurhash57 {
                                                                                                  Some(e) => {
                                                                                                    *base.add(112+37*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                    let vec59 = (e.into_bytes()).into_boxed_slice();
                                                                                                    let ptr59 = vec59.as_ptr().cast::<u8>();
                                                                                                    let len59 = vec59.len();
                                                                                                    ::core::mem::forget(vec59);
                                                                                                    *base.add(112+39*::core::mem::size_of::<*const u8>()).cast::<usize>() = len59;
                                                                                                    *base.add(112+38*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr59.cast_mut();
                                                                                                  },
                                                                                                  None => {
                                                                                                    {
                                                                                                      *base.add(112+37*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                    }
                                                                                                  },
                                                                                                };},
                                                                                                None => {
                                                                                                  {
                                                                                                    *base.add(96+33*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                  }
                                                                                                },
                                                                                              };},
                                                                                              None => {
                                                                                                {
                                                                                                  *base.add(32+4*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                }
                                                                                              },
                                                                                            };match description41 {
                                                                                              Some(e) => {
                                                                                                *base.add(112+40*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                let vec60 = (e.into_bytes()).into_boxed_slice();
                                                                                                let ptr60 = vec60.as_ptr().cast::<u8>();
                                                                                                let len60 = vec60.len();
                                                                                                ::core::mem::forget(vec60);
                                                                                                *base.add(112+42*::core::mem::size_of::<*const u8>()).cast::<usize>() = len60;
                                                                                                *base.add(112+41*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr60.cast_mut();
                                                                                              },
                                                                                              None => {
                                                                                                {
                                                                                                  *base.add(112+40*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                }
                                                                                              },
                                                                                            };match released41 {
                                                                                              Some(e) => {
                                                                                                *base.add(112+43*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                let vec61 = (e.into_bytes()).into_boxed_slice();
                                                                                                let ptr61 = vec61.as_ptr().cast::<u8>();
                                                                                                let len61 = vec61.len();
                                                                                                ::core::mem::forget(vec61);
                                                                                                *base.add(112+45*::core::mem::size_of::<*const u8>()).cast::<usize>() = len61;
                                                                                                *base.add(112+44*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr61.cast_mut();
                                                                                              },
                                                                                              None => {
                                                                                                {
                                                                                                  *base.add(112+43*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                }
                                                                                              },
                                                                                            };match score41 {
                                                                                              Some(e) => {
                                                                                                *base.add(112+46*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                *base.add(116+46*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                              },
                                                                                              None => {
                                                                                                {
                                                                                                  *base.add(112+46*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                }
                                                                                              },
                                                                                            };match url41 {
                                                                                              Some(e) => {
                                                                                                *base.add(120+46*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                let vec62 = (e.into_bytes()).into_boxed_slice();
                                                                                                let ptr62 = vec62.as_ptr().cast::<u8>();
                                                                                                let len62 = vec62.len();
                                                                                                ::core::mem::forget(vec62);
                                                                                                *base.add(120+48*::core::mem::size_of::<*const u8>()).cast::<usize>() = len62;
                                                                                                *base.add(120+47*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr62.cast_mut();
                                                                                              },
                                                                                              None => {
                                                                                                {
                                                                                                  *base.add(120+46*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                }
                                                                                              },
                                                                                            };let vec64 = tags41;
                                                                                            let len64 = vec64.len();
                                                                                            let layout64 = _rt::alloc::Layout::from_size_align(vec64.len() * (2*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>()).unwrap();
                                                                                            let (result64, _cleanup64) = wit_bindgen::rt::Cleanup::new(layout64);if let Some(cleanup) = _cleanup64 { cleanup.forget(); }
                                                                                            for (i, e) in vec64.into_iter().enumerate() {
                                                                                              let base = result64.add(i * (2*::core::mem::size_of::<*const u8>()));
                                                                                              {
                                                                                                let vec63 = (e.into_bytes()).into_boxed_slice();
                                                                                                let ptr63 = vec63.as_ptr().cast::<u8>();
                                                                                                let len63 = vec63.len();
                                                                                                ::core::mem::forget(vec63);
                                                                                                *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len63;
                                                                                                *base.add(0).cast::<*mut u8>() = ptr63.cast_mut();
                                                                                              }
                                                                                            }
                                                                                            *base.add(120+50*::core::mem::size_of::<*const u8>()).cast::<usize>() = len64;
                                                                                            *base.add(120+49*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result64;
                                                                                            let vec68 = extra41;
                                                                                            let len68 = vec68.len();
                                                                                            let layout68 = _rt::alloc::Layout::from_size_align(vec68.len() * (4*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>()).unwrap();
                                                                                            let (result68, _cleanup68) = wit_bindgen::rt::Cleanup::new(layout68);if let Some(cleanup) = _cleanup68 { cleanup.forget(); }
                                                                                            for (i, e) in vec68.into_iter().enumerate() {
                                                                                              let base = result68.add(i * (4*::core::mem::size_of::<*const u8>()));
                                                                                              {
                                                                                                let super::super::bex::plugin::common::Attr{ key:key65, value:value65, } = e;
                                                                                                let vec66 = (key65.into_bytes()).into_boxed_slice();
                                                                                                let ptr66 = vec66.as_ptr().cast::<u8>();
                                                                                                let len66 = vec66.len();
                                                                                                ::core::mem::forget(vec66);
                                                                                                *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len66;
                                                                                                *base.add(0).cast::<*mut u8>() = ptr66.cast_mut();
                                                                                                let vec67 = (value65.into_bytes()).into_boxed_slice();
                                                                                                let ptr67 = vec67.as_ptr().cast::<u8>();
                                                                                                let len67 = vec67.len();
                                                                                                ::core::mem::forget(vec67);
                                                                                                *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len67;
                                                                                                *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr67.cast_mut();
                                                                                              }
                                                                                            }
                                                                                            *base.add(120+52*::core::mem::size_of::<*const u8>()).cast::<usize>() = len68;
                                                                                            *base.add(120+51*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result68;
                                                                                          }
                                                                                        }
                                                                                        *base.add(24+5*::core::mem::size_of::<*const u8>()).cast::<usize>() = len69;
                                                                                        *base.add(24+4*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result69;
                                                                                      }
                                                                                    }
                                                                                    *ptr9.add(120+61*::core::mem::size_of::<*const u8>()).cast::<usize>() = len70;
                                                                                    *ptr9.add(120+60*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result70;
                                                                                    let vec92 = cast10;
                                                                                    let len92 = vec92.len();
                                                                                    let layout92 = _rt::alloc::Layout::from_size_align(vec92.len() * (80+46*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>()).unwrap();
                                                                                    let (result92, _cleanup92) = wit_bindgen::rt::Cleanup::new(layout92);if let Some(cleanup) = _cleanup92 { cleanup.forget(); }
                                                                                    for (i, e) in vec92.into_iter().enumerate() {
                                                                                      let base = result92.add(i * (80+46*::core::mem::size_of::<*const u8>()));
                                                                                      {
                                                                                        let super::super::bex::plugin::common::Person{ id:id71, name:name71, image:image71, role:role71, url:url71, } = e;
                                                                                        let vec72 = (id71.into_bytes()).into_boxed_slice();
                                                                                        let ptr72 = vec72.as_ptr().cast::<u8>();
                                                                                        let len72 = vec72.len();
                                                                                        ::core::mem::forget(vec72);
                                                                                        *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len72;
                                                                                        *base.add(0).cast::<*mut u8>() = ptr72.cast_mut();
                                                                                        let vec73 = (name71.into_bytes()).into_boxed_slice();
                                                                                        let ptr73 = vec73.as_ptr().cast::<u8>();
                                                                                        let len73 = vec73.len();
                                                                                        ::core::mem::forget(vec73);
                                                                                        *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len73;
                                                                                        *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr73.cast_mut();
                                                                                        match image71 {
                                                                                          Some(e) => {
                                                                                            *base.add(4*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                            let super::super::bex::plugin::common::ImageSet{ low:low74, medium:medium74, high:high74, backdrop:backdrop74, logo:logo74, } = e;
                                                                                            match low74 {
                                                                                              Some(e) => {
                                                                                                *base.add(5*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                let super::super::bex::plugin::common::Image{ url:url75, layout:layout75, width:width75, height:height75, blurhash:blurhash75, } = e;
                                                                                                let vec76 = (url75.into_bytes()).into_boxed_slice();
                                                                                                let ptr76 = vec76.as_ptr().cast::<u8>();
                                                                                                let len76 = vec76.len();
                                                                                                ::core::mem::forget(vec76);
                                                                                                *base.add(7*::core::mem::size_of::<*const u8>()).cast::<usize>() = len76;
                                                                                                *base.add(6*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr76.cast_mut();
                                                                                                *base.add(8*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout75.clone() as i32) as u8;
                                                                                                match width75 {
                                                                                                  Some(e) => {
                                                                                                    *base.add(4+8*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                    *base.add(8+8*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                  },
                                                                                                  None => {
                                                                                                    {
                                                                                                      *base.add(4+8*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                    }
                                                                                                  },
                                                                                                };match height75 {
                                                                                                  Some(e) => {
                                                                                                    *base.add(12+8*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                    *base.add(16+8*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                  },
                                                                                                  None => {
                                                                                                    {
                                                                                                      *base.add(12+8*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                    }
                                                                                                  },
                                                                                                };match blurhash75 {
                                                                                                  Some(e) => {
                                                                                                    *base.add(16+9*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                    let vec77 = (e.into_bytes()).into_boxed_slice();
                                                                                                    let ptr77 = vec77.as_ptr().cast::<u8>();
                                                                                                    let len77 = vec77.len();
                                                                                                    ::core::mem::forget(vec77);
                                                                                                    *base.add(16+11*::core::mem::size_of::<*const u8>()).cast::<usize>() = len77;
                                                                                                    *base.add(16+10*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr77.cast_mut();
                                                                                                  },
                                                                                                  None => {
                                                                                                    {
                                                                                                      *base.add(16+9*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                    }
                                                                                                  },
                                                                                                };},
                                                                                                None => {
                                                                                                  {
                                                                                                    *base.add(5*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                  }
                                                                                                },
                                                                                              };match medium74 {
                                                                                                Some(e) => {
                                                                                                  *base.add(16+12*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                  let super::super::bex::plugin::common::Image{ url:url78, layout:layout78, width:width78, height:height78, blurhash:blurhash78, } = e;
                                                                                                  let vec79 = (url78.into_bytes()).into_boxed_slice();
                                                                                                  let ptr79 = vec79.as_ptr().cast::<u8>();
                                                                                                  let len79 = vec79.len();
                                                                                                  ::core::mem::forget(vec79);
                                                                                                  *base.add(16+14*::core::mem::size_of::<*const u8>()).cast::<usize>() = len79;
                                                                                                  *base.add(16+13*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr79.cast_mut();
                                                                                                  *base.add(16+15*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout78.clone() as i32) as u8;
                                                                                                  match width78 {
                                                                                                    Some(e) => {
                                                                                                      *base.add(20+15*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                      *base.add(24+15*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                    },
                                                                                                    None => {
                                                                                                      {
                                                                                                        *base.add(20+15*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                      }
                                                                                                    },
                                                                                                  };match height78 {
                                                                                                    Some(e) => {
                                                                                                      *base.add(28+15*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                      *base.add(32+15*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                    },
                                                                                                    None => {
                                                                                                      {
                                                                                                        *base.add(28+15*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                      }
                                                                                                    },
                                                                                                  };match blurhash78 {
                                                                                                    Some(e) => {
                                                                                                      *base.add(32+16*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                      let vec80 = (e.into_bytes()).into_boxed_slice();
                                                                                                      let ptr80 = vec80.as_ptr().cast::<u8>();
                                                                                                      let len80 = vec80.len();
                                                                                                      ::core::mem::forget(vec80);
                                                                                                      *base.add(32+18*::core::mem::size_of::<*const u8>()).cast::<usize>() = len80;
                                                                                                      *base.add(32+17*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr80.cast_mut();
                                                                                                    },
                                                                                                    None => {
                                                                                                      {
                                                                                                        *base.add(32+16*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                      }
                                                                                                    },
                                                                                                  };},
                                                                                                  None => {
                                                                                                    {
                                                                                                      *base.add(16+12*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                    }
                                                                                                  },
                                                                                                };match high74 {
                                                                                                  Some(e) => {
                                                                                                    *base.add(32+19*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                    let super::super::bex::plugin::common::Image{ url:url81, layout:layout81, width:width81, height:height81, blurhash:blurhash81, } = e;
                                                                                                    let vec82 = (url81.into_bytes()).into_boxed_slice();
                                                                                                    let ptr82 = vec82.as_ptr().cast::<u8>();
                                                                                                    let len82 = vec82.len();
                                                                                                    ::core::mem::forget(vec82);
                                                                                                    *base.add(32+21*::core::mem::size_of::<*const u8>()).cast::<usize>() = len82;
                                                                                                    *base.add(32+20*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr82.cast_mut();
                                                                                                    *base.add(32+22*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout81.clone() as i32) as u8;
                                                                                                    match width81 {
                                                                                                      Some(e) => {
                                                                                                        *base.add(36+22*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                        *base.add(40+22*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                      },
                                                                                                      None => {
                                                                                                        {
                                                                                                          *base.add(36+22*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                        }
                                                                                                      },
                                                                                                    };match height81 {
                                                                                                      Some(e) => {
                                                                                                        *base.add(44+22*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                        *base.add(48+22*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                      },
                                                                                                      None => {
                                                                                                        {
                                                                                                          *base.add(44+22*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                        }
                                                                                                      },
                                                                                                    };match blurhash81 {
                                                                                                      Some(e) => {
                                                                                                        *base.add(48+23*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                        let vec83 = (e.into_bytes()).into_boxed_slice();
                                                                                                        let ptr83 = vec83.as_ptr().cast::<u8>();
                                                                                                        let len83 = vec83.len();
                                                                                                        ::core::mem::forget(vec83);
                                                                                                        *base.add(48+25*::core::mem::size_of::<*const u8>()).cast::<usize>() = len83;
                                                                                                        *base.add(48+24*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr83.cast_mut();
                                                                                                      },
                                                                                                      None => {
                                                                                                        {
                                                                                                          *base.add(48+23*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                        }
                                                                                                      },
                                                                                                    };},
                                                                                                    None => {
                                                                                                      {
                                                                                                        *base.add(32+19*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                      }
                                                                                                    },
                                                                                                  };match backdrop74 {
                                                                                                    Some(e) => {
                                                                                                      *base.add(48+26*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                      let super::super::bex::plugin::common::Image{ url:url84, layout:layout84, width:width84, height:height84, blurhash:blurhash84, } = e;
                                                                                                      let vec85 = (url84.into_bytes()).into_boxed_slice();
                                                                                                      let ptr85 = vec85.as_ptr().cast::<u8>();
                                                                                                      let len85 = vec85.len();
                                                                                                      ::core::mem::forget(vec85);
                                                                                                      *base.add(48+28*::core::mem::size_of::<*const u8>()).cast::<usize>() = len85;
                                                                                                      *base.add(48+27*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr85.cast_mut();
                                                                                                      *base.add(48+29*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout84.clone() as i32) as u8;
                                                                                                      match width84 {
                                                                                                        Some(e) => {
                                                                                                          *base.add(52+29*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                          *base.add(56+29*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                        },
                                                                                                        None => {
                                                                                                          {
                                                                                                            *base.add(52+29*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                          }
                                                                                                        },
                                                                                                      };match height84 {
                                                                                                        Some(e) => {
                                                                                                          *base.add(60+29*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                          *base.add(64+29*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                        },
                                                                                                        None => {
                                                                                                          {
                                                                                                            *base.add(60+29*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                          }
                                                                                                        },
                                                                                                      };match blurhash84 {
                                                                                                        Some(e) => {
                                                                                                          *base.add(64+30*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                          let vec86 = (e.into_bytes()).into_boxed_slice();
                                                                                                          let ptr86 = vec86.as_ptr().cast::<u8>();
                                                                                                          let len86 = vec86.len();
                                                                                                          ::core::mem::forget(vec86);
                                                                                                          *base.add(64+32*::core::mem::size_of::<*const u8>()).cast::<usize>() = len86;
                                                                                                          *base.add(64+31*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr86.cast_mut();
                                                                                                        },
                                                                                                        None => {
                                                                                                          {
                                                                                                            *base.add(64+30*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                          }
                                                                                                        },
                                                                                                      };},
                                                                                                      None => {
                                                                                                        {
                                                                                                          *base.add(48+26*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                        }
                                                                                                      },
                                                                                                    };match logo74 {
                                                                                                      Some(e) => {
                                                                                                        *base.add(64+33*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                        let super::super::bex::plugin::common::Image{ url:url87, layout:layout87, width:width87, height:height87, blurhash:blurhash87, } = e;
                                                                                                        let vec88 = (url87.into_bytes()).into_boxed_slice();
                                                                                                        let ptr88 = vec88.as_ptr().cast::<u8>();
                                                                                                        let len88 = vec88.len();
                                                                                                        ::core::mem::forget(vec88);
                                                                                                        *base.add(64+35*::core::mem::size_of::<*const u8>()).cast::<usize>() = len88;
                                                                                                        *base.add(64+34*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr88.cast_mut();
                                                                                                        *base.add(64+36*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout87.clone() as i32) as u8;
                                                                                                        match width87 {
                                                                                                          Some(e) => {
                                                                                                            *base.add(68+36*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                            *base.add(72+36*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                          },
                                                                                                          None => {
                                                                                                            {
                                                                                                              *base.add(68+36*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                            }
                                                                                                          },
                                                                                                        };match height87 {
                                                                                                          Some(e) => {
                                                                                                            *base.add(76+36*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                            *base.add(80+36*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                          },
                                                                                                          None => {
                                                                                                            {
                                                                                                              *base.add(76+36*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                            }
                                                                                                          },
                                                                                                        };match blurhash87 {
                                                                                                          Some(e) => {
                                                                                                            *base.add(80+37*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                            let vec89 = (e.into_bytes()).into_boxed_slice();
                                                                                                            let ptr89 = vec89.as_ptr().cast::<u8>();
                                                                                                            let len89 = vec89.len();
                                                                                                            ::core::mem::forget(vec89);
                                                                                                            *base.add(80+39*::core::mem::size_of::<*const u8>()).cast::<usize>() = len89;
                                                                                                            *base.add(80+38*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr89.cast_mut();
                                                                                                          },
                                                                                                          None => {
                                                                                                            {
                                                                                                              *base.add(80+37*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                            }
                                                                                                          },
                                                                                                        };},
                                                                                                        None => {
                                                                                                          {
                                                                                                            *base.add(64+33*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                          }
                                                                                                        },
                                                                                                      };},
                                                                                                      None => {
                                                                                                        {
                                                                                                          *base.add(4*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                        }
                                                                                                      },
                                                                                                    };match role71 {
                                                                                                      Some(e) => {
                                                                                                        *base.add(80+40*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                        let vec90 = (e.into_bytes()).into_boxed_slice();
                                                                                                        let ptr90 = vec90.as_ptr().cast::<u8>();
                                                                                                        let len90 = vec90.len();
                                                                                                        ::core::mem::forget(vec90);
                                                                                                        *base.add(80+42*::core::mem::size_of::<*const u8>()).cast::<usize>() = len90;
                                                                                                        *base.add(80+41*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr90.cast_mut();
                                                                                                      },
                                                                                                      None => {
                                                                                                        {
                                                                                                          *base.add(80+40*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                        }
                                                                                                      },
                                                                                                    };match url71 {
                                                                                                      Some(e) => {
                                                                                                        *base.add(80+43*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                        let vec91 = (e.into_bytes()).into_boxed_slice();
                                                                                                        let ptr91 = vec91.as_ptr().cast::<u8>();
                                                                                                        let len91 = vec91.len();
                                                                                                        ::core::mem::forget(vec91);
                                                                                                        *base.add(80+45*::core::mem::size_of::<*const u8>()).cast::<usize>() = len91;
                                                                                                        *base.add(80+44*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr91.cast_mut();
                                                                                                      },
                                                                                                      None => {
                                                                                                        {
                                                                                                          *base.add(80+43*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                        }
                                                                                                      },
                                                                                                    };}
                                                                                                  }
                                                                                                  *ptr9.add(120+63*::core::mem::size_of::<*const u8>()).cast::<usize>() = len92;
                                                                                                  *ptr9.add(120+62*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result92;
                                                                                                  let vec114 = crew10;
                                                                                                  let len114 = vec114.len();
                                                                                                  let layout114 = _rt::alloc::Layout::from_size_align(vec114.len() * (80+46*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>()).unwrap();
                                                                                                  let (result114, _cleanup114) = wit_bindgen::rt::Cleanup::new(layout114);if let Some(cleanup) = _cleanup114 { cleanup.forget(); }
                                                                                                  for (i, e) in vec114.into_iter().enumerate() {
                                                                                                    let base = result114.add(i * (80+46*::core::mem::size_of::<*const u8>()));
                                                                                                    {
                                                                                                      let super::super::bex::plugin::common::Person{ id:id93, name:name93, image:image93, role:role93, url:url93, } = e;
                                                                                                      let vec94 = (id93.into_bytes()).into_boxed_slice();
                                                                                                      let ptr94 = vec94.as_ptr().cast::<u8>();
                                                                                                      let len94 = vec94.len();
                                                                                                      ::core::mem::forget(vec94);
                                                                                                      *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len94;
                                                                                                      *base.add(0).cast::<*mut u8>() = ptr94.cast_mut();
                                                                                                      let vec95 = (name93.into_bytes()).into_boxed_slice();
                                                                                                      let ptr95 = vec95.as_ptr().cast::<u8>();
                                                                                                      let len95 = vec95.len();
                                                                                                      ::core::mem::forget(vec95);
                                                                                                      *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len95;
                                                                                                      *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr95.cast_mut();
                                                                                                      match image93 {
                                                                                                        Some(e) => {
                                                                                                          *base.add(4*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                          let super::super::bex::plugin::common::ImageSet{ low:low96, medium:medium96, high:high96, backdrop:backdrop96, logo:logo96, } = e;
                                                                                                          match low96 {
                                                                                                            Some(e) => {
                                                                                                              *base.add(5*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                              let super::super::bex::plugin::common::Image{ url:url97, layout:layout97, width:width97, height:height97, blurhash:blurhash97, } = e;
                                                                                                              let vec98 = (url97.into_bytes()).into_boxed_slice();
                                                                                                              let ptr98 = vec98.as_ptr().cast::<u8>();
                                                                                                              let len98 = vec98.len();
                                                                                                              ::core::mem::forget(vec98);
                                                                                                              *base.add(7*::core::mem::size_of::<*const u8>()).cast::<usize>() = len98;
                                                                                                              *base.add(6*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr98.cast_mut();
                                                                                                              *base.add(8*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout97.clone() as i32) as u8;
                                                                                                              match width97 {
                                                                                                                Some(e) => {
                                                                                                                  *base.add(4+8*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                  *base.add(8+8*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                                },
                                                                                                                None => {
                                                                                                                  {
                                                                                                                    *base.add(4+8*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                  }
                                                                                                                },
                                                                                                              };match height97 {
                                                                                                                Some(e) => {
                                                                                                                  *base.add(12+8*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                  *base.add(16+8*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                                },
                                                                                                                None => {
                                                                                                                  {
                                                                                                                    *base.add(12+8*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                  }
                                                                                                                },
                                                                                                              };match blurhash97 {
                                                                                                                Some(e) => {
                                                                                                                  *base.add(16+9*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                  let vec99 = (e.into_bytes()).into_boxed_slice();
                                                                                                                  let ptr99 = vec99.as_ptr().cast::<u8>();
                                                                                                                  let len99 = vec99.len();
                                                                                                                  ::core::mem::forget(vec99);
                                                                                                                  *base.add(16+11*::core::mem::size_of::<*const u8>()).cast::<usize>() = len99;
                                                                                                                  *base.add(16+10*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr99.cast_mut();
                                                                                                                },
                                                                                                                None => {
                                                                                                                  {
                                                                                                                    *base.add(16+9*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                  }
                                                                                                                },
                                                                                                              };},
                                                                                                              None => {
                                                                                                                {
                                                                                                                  *base.add(5*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                }
                                                                                                              },
                                                                                                            };match medium96 {
                                                                                                              Some(e) => {
                                                                                                                *base.add(16+12*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                let super::super::bex::plugin::common::Image{ url:url100, layout:layout100, width:width100, height:height100, blurhash:blurhash100, } = e;
                                                                                                                let vec101 = (url100.into_bytes()).into_boxed_slice();
                                                                                                                let ptr101 = vec101.as_ptr().cast::<u8>();
                                                                                                                let len101 = vec101.len();
                                                                                                                ::core::mem::forget(vec101);
                                                                                                                *base.add(16+14*::core::mem::size_of::<*const u8>()).cast::<usize>() = len101;
                                                                                                                *base.add(16+13*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr101.cast_mut();
                                                                                                                *base.add(16+15*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout100.clone() as i32) as u8;
                                                                                                                match width100 {
                                                                                                                  Some(e) => {
                                                                                                                    *base.add(20+15*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                    *base.add(24+15*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                                  },
                                                                                                                  None => {
                                                                                                                    {
                                                                                                                      *base.add(20+15*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                    }
                                                                                                                  },
                                                                                                                };match height100 {
                                                                                                                  Some(e) => {
                                                                                                                    *base.add(28+15*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                    *base.add(32+15*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                                  },
                                                                                                                  None => {
                                                                                                                    {
                                                                                                                      *base.add(28+15*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                    }
                                                                                                                  },
                                                                                                                };match blurhash100 {
                                                                                                                  Some(e) => {
                                                                                                                    *base.add(32+16*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                    let vec102 = (e.into_bytes()).into_boxed_slice();
                                                                                                                    let ptr102 = vec102.as_ptr().cast::<u8>();
                                                                                                                    let len102 = vec102.len();
                                                                                                                    ::core::mem::forget(vec102);
                                                                                                                    *base.add(32+18*::core::mem::size_of::<*const u8>()).cast::<usize>() = len102;
                                                                                                                    *base.add(32+17*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr102.cast_mut();
                                                                                                                  },
                                                                                                                  None => {
                                                                                                                    {
                                                                                                                      *base.add(32+16*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                    }
                                                                                                                  },
                                                                                                                };},
                                                                                                                None => {
                                                                                                                  {
                                                                                                                    *base.add(16+12*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                  }
                                                                                                                },
                                                                                                              };match high96 {
                                                                                                                Some(e) => {
                                                                                                                  *base.add(32+19*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                  let super::super::bex::plugin::common::Image{ url:url103, layout:layout103, width:width103, height:height103, blurhash:blurhash103, } = e;
                                                                                                                  let vec104 = (url103.into_bytes()).into_boxed_slice();
                                                                                                                  let ptr104 = vec104.as_ptr().cast::<u8>();
                                                                                                                  let len104 = vec104.len();
                                                                                                                  ::core::mem::forget(vec104);
                                                                                                                  *base.add(32+21*::core::mem::size_of::<*const u8>()).cast::<usize>() = len104;
                                                                                                                  *base.add(32+20*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr104.cast_mut();
                                                                                                                  *base.add(32+22*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout103.clone() as i32) as u8;
                                                                                                                  match width103 {
                                                                                                                    Some(e) => {
                                                                                                                      *base.add(36+22*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                      *base.add(40+22*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                                    },
                                                                                                                    None => {
                                                                                                                      {
                                                                                                                        *base.add(36+22*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                      }
                                                                                                                    },
                                                                                                                  };match height103 {
                                                                                                                    Some(e) => {
                                                                                                                      *base.add(44+22*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                      *base.add(48+22*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                                    },
                                                                                                                    None => {
                                                                                                                      {
                                                                                                                        *base.add(44+22*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                      }
                                                                                                                    },
                                                                                                                  };match blurhash103 {
                                                                                                                    Some(e) => {
                                                                                                                      *base.add(48+23*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                      let vec105 = (e.into_bytes()).into_boxed_slice();
                                                                                                                      let ptr105 = vec105.as_ptr().cast::<u8>();
                                                                                                                      let len105 = vec105.len();
                                                                                                                      ::core::mem::forget(vec105);
                                                                                                                      *base.add(48+25*::core::mem::size_of::<*const u8>()).cast::<usize>() = len105;
                                                                                                                      *base.add(48+24*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr105.cast_mut();
                                                                                                                    },
                                                                                                                    None => {
                                                                                                                      {
                                                                                                                        *base.add(48+23*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                      }
                                                                                                                    },
                                                                                                                  };},
                                                                                                                  None => {
                                                                                                                    {
                                                                                                                      *base.add(32+19*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                    }
                                                                                                                  },
                                                                                                                };match backdrop96 {
                                                                                                                  Some(e) => {
                                                                                                                    *base.add(48+26*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                    let super::super::bex::plugin::common::Image{ url:url106, layout:layout106, width:width106, height:height106, blurhash:blurhash106, } = e;
                                                                                                                    let vec107 = (url106.into_bytes()).into_boxed_slice();
                                                                                                                    let ptr107 = vec107.as_ptr().cast::<u8>();
                                                                                                                    let len107 = vec107.len();
                                                                                                                    ::core::mem::forget(vec107);
                                                                                                                    *base.add(48+28*::core::mem::size_of::<*const u8>()).cast::<usize>() = len107;
                                                                                                                    *base.add(48+27*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr107.cast_mut();
                                                                                                                    *base.add(48+29*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout106.clone() as i32) as u8;
                                                                                                                    match width106 {
                                                                                                                      Some(e) => {
                                                                                                                        *base.add(52+29*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                        *base.add(56+29*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                                      },
                                                                                                                      None => {
                                                                                                                        {
                                                                                                                          *base.add(52+29*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                        }
                                                                                                                      },
                                                                                                                    };match height106 {
                                                                                                                      Some(e) => {
                                                                                                                        *base.add(60+29*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                        *base.add(64+29*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                                      },
                                                                                                                      None => {
                                                                                                                        {
                                                                                                                          *base.add(60+29*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                        }
                                                                                                                      },
                                                                                                                    };match blurhash106 {
                                                                                                                      Some(e) => {
                                                                                                                        *base.add(64+30*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                        let vec108 = (e.into_bytes()).into_boxed_slice();
                                                                                                                        let ptr108 = vec108.as_ptr().cast::<u8>();
                                                                                                                        let len108 = vec108.len();
                                                                                                                        ::core::mem::forget(vec108);
                                                                                                                        *base.add(64+32*::core::mem::size_of::<*const u8>()).cast::<usize>() = len108;
                                                                                                                        *base.add(64+31*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr108.cast_mut();
                                                                                                                      },
                                                                                                                      None => {
                                                                                                                        {
                                                                                                                          *base.add(64+30*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                        }
                                                                                                                      },
                                                                                                                    };},
                                                                                                                    None => {
                                                                                                                      {
                                                                                                                        *base.add(48+26*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                      }
                                                                                                                    },
                                                                                                                  };match logo96 {
                                                                                                                    Some(e) => {
                                                                                                                      *base.add(64+33*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                      let super::super::bex::plugin::common::Image{ url:url109, layout:layout109, width:width109, height:height109, blurhash:blurhash109, } = e;
                                                                                                                      let vec110 = (url109.into_bytes()).into_boxed_slice();
                                                                                                                      let ptr110 = vec110.as_ptr().cast::<u8>();
                                                                                                                      let len110 = vec110.len();
                                                                                                                      ::core::mem::forget(vec110);
                                                                                                                      *base.add(64+35*::core::mem::size_of::<*const u8>()).cast::<usize>() = len110;
                                                                                                                      *base.add(64+34*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr110.cast_mut();
                                                                                                                      *base.add(64+36*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout109.clone() as i32) as u8;
                                                                                                                      match width109 {
                                                                                                                        Some(e) => {
                                                                                                                          *base.add(68+36*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                          *base.add(72+36*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                                        },
                                                                                                                        None => {
                                                                                                                          {
                                                                                                                            *base.add(68+36*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                          }
                                                                                                                        },
                                                                                                                      };match height109 {
                                                                                                                        Some(e) => {
                                                                                                                          *base.add(76+36*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                          *base.add(80+36*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                                        },
                                                                                                                        None => {
                                                                                                                          {
                                                                                                                            *base.add(76+36*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                          }
                                                                                                                        },
                                                                                                                      };match blurhash109 {
                                                                                                                        Some(e) => {
                                                                                                                          *base.add(80+37*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                          let vec111 = (e.into_bytes()).into_boxed_slice();
                                                                                                                          let ptr111 = vec111.as_ptr().cast::<u8>();
                                                                                                                          let len111 = vec111.len();
                                                                                                                          ::core::mem::forget(vec111);
                                                                                                                          *base.add(80+39*::core::mem::size_of::<*const u8>()).cast::<usize>() = len111;
                                                                                                                          *base.add(80+38*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr111.cast_mut();
                                                                                                                        },
                                                                                                                        None => {
                                                                                                                          {
                                                                                                                            *base.add(80+37*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                          }
                                                                                                                        },
                                                                                                                      };},
                                                                                                                      None => {
                                                                                                                        {
                                                                                                                          *base.add(64+33*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                        }
                                                                                                                      },
                                                                                                                    };},
                                                                                                                    None => {
                                                                                                                      {
                                                                                                                        *base.add(4*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                      }
                                                                                                                    },
                                                                                                                  };match role93 {
                                                                                                                    Some(e) => {
                                                                                                                      *base.add(80+40*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                      let vec112 = (e.into_bytes()).into_boxed_slice();
                                                                                                                      let ptr112 = vec112.as_ptr().cast::<u8>();
                                                                                                                      let len112 = vec112.len();
                                                                                                                      ::core::mem::forget(vec112);
                                                                                                                      *base.add(80+42*::core::mem::size_of::<*const u8>()).cast::<usize>() = len112;
                                                                                                                      *base.add(80+41*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr112.cast_mut();
                                                                                                                    },
                                                                                                                    None => {
                                                                                                                      {
                                                                                                                        *base.add(80+40*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                      }
                                                                                                                    },
                                                                                                                  };match url93 {
                                                                                                                    Some(e) => {
                                                                                                                      *base.add(80+43*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                      let vec113 = (e.into_bytes()).into_boxed_slice();
                                                                                                                      let ptr113 = vec113.as_ptr().cast::<u8>();
                                                                                                                      let len113 = vec113.len();
                                                                                                                      ::core::mem::forget(vec113);
                                                                                                                      *base.add(80+45*::core::mem::size_of::<*const u8>()).cast::<usize>() = len113;
                                                                                                                      *base.add(80+44*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr113.cast_mut();
                                                                                                                    },
                                                                                                                    None => {
                                                                                                                      {
                                                                                                                        *base.add(80+43*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                      }
                                                                                                                    },
                                                                                                                  };}
                                                                                                                }
                                                                                                                *ptr9.add(120+65*::core::mem::size_of::<*const u8>()).cast::<usize>() = len114;
                                                                                                                *ptr9.add(120+64*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result114;
                                                                                                                match runtime_minutes10 {
                                                                                                                  Some(e) => {
                                                                                                                    *ptr9.add(120+66*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                    *ptr9.add(124+66*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                                  },
                                                                                                                  None => {
                                                                                                                    {
                                                                                                                      *ptr9.add(120+66*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                    }
                                                                                                                  },
                                                                                                                };match trailer_url10 {
                                                                                                                  Some(e) => {
                                                                                                                    *ptr9.add(128+66*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                    let vec115 = (e.into_bytes()).into_boxed_slice();
                                                                                                                    let ptr115 = vec115.as_ptr().cast::<u8>();
                                                                                                                    let len115 = vec115.len();
                                                                                                                    ::core::mem::forget(vec115);
                                                                                                                    *ptr9.add(128+68*::core::mem::size_of::<*const u8>()).cast::<usize>() = len115;
                                                                                                                    *ptr9.add(128+67*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr115.cast_mut();
                                                                                                                  },
                                                                                                                  None => {
                                                                                                                    {
                                                                                                                      *ptr9.add(128+66*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                    }
                                                                                                                  },
                                                                                                                };let vec119 = ids10;
                                                                                                                let len119 = vec119.len();
                                                                                                                let layout119 = _rt::alloc::Layout::from_size_align(vec119.len() * (4*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>()).unwrap();
                                                                                                                let (result119, _cleanup119) = wit_bindgen::rt::Cleanup::new(layout119);if let Some(cleanup) = _cleanup119 { cleanup.forget(); }
                                                                                                                for (i, e) in vec119.into_iter().enumerate() {
                                                                                                                  let base = result119.add(i * (4*::core::mem::size_of::<*const u8>()));
                                                                                                                  {
                                                                                                                    let super::super::bex::plugin::common::LinkedId{ source:source116, id:id116, } = e;
                                                                                                                    let vec117 = (source116.into_bytes()).into_boxed_slice();
                                                                                                                    let ptr117 = vec117.as_ptr().cast::<u8>();
                                                                                                                    let len117 = vec117.len();
                                                                                                                    ::core::mem::forget(vec117);
                                                                                                                    *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len117;
                                                                                                                    *base.add(0).cast::<*mut u8>() = ptr117.cast_mut();
                                                                                                                    let vec118 = (id116.into_bytes()).into_boxed_slice();
                                                                                                                    let ptr118 = vec118.as_ptr().cast::<u8>();
                                                                                                                    let len118 = vec118.len();
                                                                                                                    ::core::mem::forget(vec118);
                                                                                                                    *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len118;
                                                                                                                    *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr118.cast_mut();
                                                                                                                  }
                                                                                                                }
                                                                                                                *ptr9.add(128+70*::core::mem::size_of::<*const u8>()).cast::<usize>() = len119;
                                                                                                                *ptr9.add(128+69*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result119;
                                                                                                                match studio10 {
                                                                                                                  Some(e) => {
                                                                                                                    *ptr9.add(128+71*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                    let vec120 = (e.into_bytes()).into_boxed_slice();
                                                                                                                    let ptr120 = vec120.as_ptr().cast::<u8>();
                                                                                                                    let len120 = vec120.len();
                                                                                                                    ::core::mem::forget(vec120);
                                                                                                                    *ptr9.add(128+73*::core::mem::size_of::<*const u8>()).cast::<usize>() = len120;
                                                                                                                    *ptr9.add(128+72*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr120.cast_mut();
                                                                                                                  },
                                                                                                                  None => {
                                                                                                                    {
                                                                                                                      *ptr9.add(128+71*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                    }
                                                                                                                  },
                                                                                                                };match country10 {
                                                                                                                  Some(e) => {
                                                                                                                    *ptr9.add(128+74*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                    let vec121 = (e.into_bytes()).into_boxed_slice();
                                                                                                                    let ptr121 = vec121.as_ptr().cast::<u8>();
                                                                                                                    let len121 = vec121.len();
                                                                                                                    ::core::mem::forget(vec121);
                                                                                                                    *ptr9.add(128+76*::core::mem::size_of::<*const u8>()).cast::<usize>() = len121;
                                                                                                                    *ptr9.add(128+75*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr121.cast_mut();
                                                                                                                  },
                                                                                                                  None => {
                                                                                                                    {
                                                                                                                      *ptr9.add(128+74*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                    }
                                                                                                                  },
                                                                                                                };match language10 {
                                                                                                                  Some(e) => {
                                                                                                                    *ptr9.add(128+77*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                    let vec122 = (e.into_bytes()).into_boxed_slice();
                                                                                                                    let ptr122 = vec122.as_ptr().cast::<u8>();
                                                                                                                    let len122 = vec122.len();
                                                                                                                    ::core::mem::forget(vec122);
                                                                                                                    *ptr9.add(128+79*::core::mem::size_of::<*const u8>()).cast::<usize>() = len122;
                                                                                                                    *ptr9.add(128+78*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr122.cast_mut();
                                                                                                                  },
                                                                                                                  None => {
                                                                                                                    {
                                                                                                                      *ptr9.add(128+77*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                    }
                                                                                                                  },
                                                                                                                };match url10 {
                                                                                                                  Some(e) => {
                                                                                                                    *ptr9.add(128+80*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                    let vec123 = (e.into_bytes()).into_boxed_slice();
                                                                                                                    let ptr123 = vec123.as_ptr().cast::<u8>();
                                                                                                                    let len123 = vec123.len();
                                                                                                                    ::core::mem::forget(vec123);
                                                                                                                    *ptr9.add(128+82*::core::mem::size_of::<*const u8>()).cast::<usize>() = len123;
                                                                                                                    *ptr9.add(128+81*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr123.cast_mut();
                                                                                                                  },
                                                                                                                  None => {
                                                                                                                    {
                                                                                                                      *ptr9.add(128+80*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                    }
                                                                                                                  },
                                                                                                                };let vec127 = extra10;
                                                                                                                let len127 = vec127.len();
                                                                                                                let layout127 = _rt::alloc::Layout::from_size_align(vec127.len() * (4*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>()).unwrap();
                                                                                                                let (result127, _cleanup127) = wit_bindgen::rt::Cleanup::new(layout127);if let Some(cleanup) = _cleanup127 { cleanup.forget(); }
                                                                                                                for (i, e) in vec127.into_iter().enumerate() {
                                                                                                                  let base = result127.add(i * (4*::core::mem::size_of::<*const u8>()));
                                                                                                                  {
                                                                                                                    let super::super::bex::plugin::common::Attr{ key:key124, value:value124, } = e;
                                                                                                                    let vec125 = (key124.into_bytes()).into_boxed_slice();
                                                                                                                    let ptr125 = vec125.as_ptr().cast::<u8>();
                                                                                                                    let len125 = vec125.len();
                                                                                                                    ::core::mem::forget(vec125);
                                                                                                                    *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len125;
                                                                                                                    *base.add(0).cast::<*mut u8>() = ptr125.cast_mut();
                                                                                                                    let vec126 = (value124.into_bytes()).into_boxed_slice();
                                                                                                                    let ptr126 = vec126.as_ptr().cast::<u8>();
                                                                                                                    let len126 = vec126.len();
                                                                                                                    ::core::mem::forget(vec126);
                                                                                                                    *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len126;
                                                                                                                    *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr126.cast_mut();
                                                                                                                  }
                                                                                                                }
                                                                                                                *ptr9.add(128+84*::core::mem::size_of::<*const u8>()).cast::<usize>() = len127;
                                                                                                                *ptr9.add(128+83*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result127;
                                                                                                              } },
                                                                                                              Err(e) => { {
                                                                                                                *ptr9.add(0).cast::<u8>() = (1i32) as u8;
                                                                                                                use super::super::bex::plugin::common::PluginError as V132;
                                                                                                                match e {
                                                                                                                  V132::Network(e) => {
                                                                                                                    *ptr9.add(8).cast::<u8>() = (0i32) as u8;
                                                                                                                    let vec128 = (e.into_bytes()).into_boxed_slice();
                                                                                                                    let ptr128 = vec128.as_ptr().cast::<u8>();
                                                                                                                    let len128 = vec128.len();
                                                                                                                    ::core::mem::forget(vec128);
                                                                                                                    *ptr9.add(8+2*::core::mem::size_of::<*const u8>()).cast::<usize>() = len128;
                                                                                                                    *ptr9.add(8+1*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr128.cast_mut();
                                                                                                                  },
                                                                                                                  V132::Parse(e) => {
                                                                                                                    *ptr9.add(8).cast::<u8>() = (1i32) as u8;
                                                                                                                    let vec129 = (e.into_bytes()).into_boxed_slice();
                                                                                                                    let ptr129 = vec129.as_ptr().cast::<u8>();
                                                                                                                    let len129 = vec129.len();
                                                                                                                    ::core::mem::forget(vec129);
                                                                                                                    *ptr9.add(8+2*::core::mem::size_of::<*const u8>()).cast::<usize>() = len129;
                                                                                                                    *ptr9.add(8+1*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr129.cast_mut();
                                                                                                                  },
                                                                                                                  V132::NotFound=> {
                                                                                                                    {
                                                                                                                      *ptr9.add(8).cast::<u8>() = (2i32) as u8;
                                                                                                                    }
                                                                                                                  }
                                                                                                                  V132::Unauthorized=> {
                                                                                                                    {
                                                                                                                      *ptr9.add(8).cast::<u8>() = (3i32) as u8;
                                                                                                                    }
                                                                                                                  }
                                                                                                                  V132::Forbidden=> {
                                                                                                                    {
                                                                                                                      *ptr9.add(8).cast::<u8>() = (4i32) as u8;
                                                                                                                    }
                                                                                                                  }
                                                                                                                  V132::RateLimited(e) => {
                                                                                                                    *ptr9.add(8).cast::<u8>() = (5i32) as u8;
                                                                                                                    match e {
                                                                                                                      Some(e) => {
                                                                                                                        *ptr9.add(8+1*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                        *ptr9.add(12+1*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                                      },
                                                                                                                      None => {
                                                                                                                        {
                                                                                                                          *ptr9.add(8+1*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                        }
                                                                                                                      },
                                                                                                                    };},
                                                                                                                    V132::Timeout=> {
                                                                                                                      {
                                                                                                                        *ptr9.add(8).cast::<u8>() = (6i32) as u8;
                                                                                                                      }
                                                                                                                    }
                                                                                                                    V132::Cancelled=> {
                                                                                                                      {
                                                                                                                        *ptr9.add(8).cast::<u8>() = (7i32) as u8;
                                                                                                                      }
                                                                                                                    }
                                                                                                                    V132::Unsupported=> {
                                                                                                                      {
                                                                                                                        *ptr9.add(8).cast::<u8>() = (8i32) as u8;
                                                                                                                      }
                                                                                                                    }
                                                                                                                    V132::InvalidInput(e) => {
                                                                                                                      *ptr9.add(8).cast::<u8>() = (9i32) as u8;
                                                                                                                      let vec130 = (e.into_bytes()).into_boxed_slice();
                                                                                                                      let ptr130 = vec130.as_ptr().cast::<u8>();
                                                                                                                      let len130 = vec130.len();
                                                                                                                      ::core::mem::forget(vec130);
                                                                                                                      *ptr9.add(8+2*::core::mem::size_of::<*const u8>()).cast::<usize>() = len130;
                                                                                                                      *ptr9.add(8+1*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr130.cast_mut();
                                                                                                                    },
                                                                                                                    V132::Internal(e) => {
                                                                                                                      *ptr9.add(8).cast::<u8>() = (10i32) as u8;
                                                                                                                      let vec131 = (e.into_bytes()).into_boxed_slice();
                                                                                                                      let ptr131 = vec131.as_ptr().cast::<u8>();
                                                                                                                      let len131 = vec131.len();
                                                                                                                      ::core::mem::forget(vec131);
                                                                                                                      *ptr9.add(8+2*::core::mem::size_of::<*const u8>()).cast::<usize>() = len131;
                                                                                                                      *ptr9.add(8+1*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr131.cast_mut();
                                                                                                                    },
                                                                                                                  }
                                                                                                                } },
                                                                                                              };ptr9
                                                                                                            } }
                                                                                                            #[doc(hidden)]
                                                                                                            #[allow(non_snake_case)]
                                                                                                            pub unsafe fn __post_return_get_info<T_: Guest>(arg0: *mut u8,) { unsafe {
                                                                                                              let l0 = i32::from(*arg0.add(0).cast::<u8>());
                                                                                                              match l0 {
                                                                                                                0 => {
                                                                                                                  let l1 = *arg0.add(8).cast::<*mut u8>();
                                                                                                                  let l2 = *arg0.add(8+1*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                  _rt::cabi_dealloc(l1, l2, 1);
                                                                                                                  let l3 = *arg0.add(8+2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                  let l4 = *arg0.add(8+3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                  _rt::cabi_dealloc(l3, l4, 1);
                                                                                                                  let l5 = i32::from(*arg0.add(8+5*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                  match l5 {
                                                                                                                    0 => (),
                                                                                                                    _ => {
                                                                                                                      let l6 = i32::from(*arg0.add(8+6*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                      match l6 {
                                                                                                                        0 => (),
                                                                                                                        _ => {
                                                                                                                          let l7 = *arg0.add(8+7*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                          let l8 = *arg0.add(8+8*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          _rt::cabi_dealloc(l7, l8, 1);
                                                                                                                          let l9 = i32::from(*arg0.add(24+10*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                          match l9 {
                                                                                                                            0 => (),
                                                                                                                            _ => {
                                                                                                                              let l10 = *arg0.add(24+11*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                              let l11 = *arg0.add(24+12*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                              _rt::cabi_dealloc(l10, l11, 1);
                                                                                                                            },
                                                                                                                          }
                                                                                                                        },
                                                                                                                      }
                                                                                                                      let l12 = i32::from(*arg0.add(24+13*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                      match l12 {
                                                                                                                        0 => (),
                                                                                                                        _ => {
                                                                                                                          let l13 = *arg0.add(24+14*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                          let l14 = *arg0.add(24+15*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          _rt::cabi_dealloc(l13, l14, 1);
                                                                                                                          let l15 = i32::from(*arg0.add(40+17*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                          match l15 {
                                                                                                                            0 => (),
                                                                                                                            _ => {
                                                                                                                              let l16 = *arg0.add(40+18*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                              let l17 = *arg0.add(40+19*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                              _rt::cabi_dealloc(l16, l17, 1);
                                                                                                                            },
                                                                                                                          }
                                                                                                                        },
                                                                                                                      }
                                                                                                                      let l18 = i32::from(*arg0.add(40+20*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                      match l18 {
                                                                                                                        0 => (),
                                                                                                                        _ => {
                                                                                                                          let l19 = *arg0.add(40+21*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                          let l20 = *arg0.add(40+22*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          _rt::cabi_dealloc(l19, l20, 1);
                                                                                                                          let l21 = i32::from(*arg0.add(56+24*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                          match l21 {
                                                                                                                            0 => (),
                                                                                                                            _ => {
                                                                                                                              let l22 = *arg0.add(56+25*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                              let l23 = *arg0.add(56+26*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                              _rt::cabi_dealloc(l22, l23, 1);
                                                                                                                            },
                                                                                                                          }
                                                                                                                        },
                                                                                                                      }
                                                                                                                      let l24 = i32::from(*arg0.add(56+27*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                      match l24 {
                                                                                                                        0 => (),
                                                                                                                        _ => {
                                                                                                                          let l25 = *arg0.add(56+28*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                          let l26 = *arg0.add(56+29*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          _rt::cabi_dealloc(l25, l26, 1);
                                                                                                                          let l27 = i32::from(*arg0.add(72+31*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                          match l27 {
                                                                                                                            0 => (),
                                                                                                                            _ => {
                                                                                                                              let l28 = *arg0.add(72+32*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                              let l29 = *arg0.add(72+33*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                              _rt::cabi_dealloc(l28, l29, 1);
                                                                                                                            },
                                                                                                                          }
                                                                                                                        },
                                                                                                                      }
                                                                                                                      let l30 = i32::from(*arg0.add(72+34*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                      match l30 {
                                                                                                                        0 => (),
                                                                                                                        _ => {
                                                                                                                          let l31 = *arg0.add(72+35*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                          let l32 = *arg0.add(72+36*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          _rt::cabi_dealloc(l31, l32, 1);
                                                                                                                          let l33 = i32::from(*arg0.add(88+38*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                          match l33 {
                                                                                                                            0 => (),
                                                                                                                            _ => {
                                                                                                                              let l34 = *arg0.add(88+39*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                              let l35 = *arg0.add(88+40*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                              _rt::cabi_dealloc(l34, l35, 1);
                                                                                                                            },
                                                                                                                          }
                                                                                                                        },
                                                                                                                      }
                                                                                                                    },
                                                                                                                  }
                                                                                                                  let l36 = i32::from(*arg0.add(88+41*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                  match l36 {
                                                                                                                    0 => (),
                                                                                                                    _ => {
                                                                                                                      let l37 = *arg0.add(88+42*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                      let l38 = *arg0.add(88+43*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      _rt::cabi_dealloc(l37, l38, 1);
                                                                                                                    },
                                                                                                                  }
                                                                                                                  let l39 = i32::from(*arg0.add(88+44*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                  match l39 {
                                                                                                                    0 => (),
                                                                                                                    _ => {
                                                                                                                      let l40 = *arg0.add(88+45*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                      let l41 = *arg0.add(88+46*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      _rt::cabi_dealloc(l40, l41, 1);
                                                                                                                    },
                                                                                                                  }
                                                                                                                  let l42 = i32::from(*arg0.add(120+46*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                  match l42 {
                                                                                                                    0 => (),
                                                                                                                    _ => {
                                                                                                                      let l43 = *arg0.add(120+47*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                      let l44 = *arg0.add(120+48*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      _rt::cabi_dealloc(l43, l44, 1);
                                                                                                                    },
                                                                                                                  }
                                                                                                                  let l45 = i32::from(*arg0.add(120+49*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                  match l45 {
                                                                                                                    0 => (),
                                                                                                                    _ => {
                                                                                                                      let l46 = *arg0.add(120+50*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                      let l47 = *arg0.add(120+51*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      _rt::cabi_dealloc(l46, l47, 1);
                                                                                                                    },
                                                                                                                  }
                                                                                                                  let l48 = *arg0.add(120+52*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                  let l49 = *arg0.add(120+53*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                  let base52 = l48;
                                                                                                                  let len52 = l49;
                                                                                                                  for i in 0..len52 {
                                                                                                                    let base = base52.add(i * (2*::core::mem::size_of::<*const u8>()));
                                                                                                                    {
                                                                                                                      let l50 = *base.add(0).cast::<*mut u8>();
                                                                                                                      let l51 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      _rt::cabi_dealloc(l50, l51, 1);
                                                                                                                    }
                                                                                                                  }
                                                                                                                  _rt::cabi_dealloc(base52, len52 * (2*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                                                                                                  let l53 = *arg0.add(120+54*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                  let l54 = *arg0.add(120+55*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                  let base57 = l53;
                                                                                                                  let len57 = l54;
                                                                                                                  for i in 0..len57 {
                                                                                                                    let base = base57.add(i * (2*::core::mem::size_of::<*const u8>()));
                                                                                                                    {
                                                                                                                      let l55 = *base.add(0).cast::<*mut u8>();
                                                                                                                      let l56 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      _rt::cabi_dealloc(l55, l56, 1);
                                                                                                                    }
                                                                                                                  }
                                                                                                                  _rt::cabi_dealloc(base57, len57 * (2*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                                                                                                  let l58 = i32::from(*arg0.add(120+57*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                  match l58 {
                                                                                                                    0 => (),
                                                                                                                    _ => {
                                                                                                                      let l59 = *arg0.add(120+58*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                      let l60 = *arg0.add(120+59*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      _rt::cabi_dealloc(l59, l60, 1);
                                                                                                                    },
                                                                                                                  }
                                                                                                                  let l61 = *arg0.add(120+60*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                  let l62 = *arg0.add(120+61*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                  let base126 = l61;
                                                                                                                  let len126 = l62;
                                                                                                                  for i in 0..len126 {
                                                                                                                    let base = base126.add(i * (24+6*::core::mem::size_of::<*const u8>()));
                                                                                                                    {
                                                                                                                      let l63 = *base.add(0).cast::<*mut u8>();
                                                                                                                      let l64 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      _rt::cabi_dealloc(l63, l64, 1);
                                                                                                                      let l65 = *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                      let l66 = *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      _rt::cabi_dealloc(l65, l66, 1);
                                                                                                                      let l67 = *base.add(24+4*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                      let l68 = *base.add(24+5*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      let base125 = l67;
                                                                                                                      let len125 = l68;
                                                                                                                      for i in 0..len125 {
                                                                                                                        let base = base125.add(i * (128+52*::core::mem::size_of::<*const u8>()));
                                                                                                                        {
                                                                                                                          let l69 = *base.add(0).cast::<*mut u8>();
                                                                                                                          let l70 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          _rt::cabi_dealloc(l69, l70, 1);
                                                                                                                          let l71 = *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                          let l72 = *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          _rt::cabi_dealloc(l71, l72, 1);
                                                                                                                          let l73 = i32::from(*base.add(32+4*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                          match l73 {
                                                                                                                            0 => (),
                                                                                                                            _ => {
                                                                                                                              let l74 = i32::from(*base.add(32+5*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                              match l74 {
                                                                                                                                0 => (),
                                                                                                                                _ => {
                                                                                                                                  let l75 = *base.add(32+6*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                  let l76 = *base.add(32+7*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                  _rt::cabi_dealloc(l75, l76, 1);
                                                                                                                                  let l77 = i32::from(*base.add(48+9*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                                  match l77 {
                                                                                                                                    0 => (),
                                                                                                                                    _ => {
                                                                                                                                      let l78 = *base.add(48+10*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                      let l79 = *base.add(48+11*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                      _rt::cabi_dealloc(l78, l79, 1);
                                                                                                                                    },
                                                                                                                                  }
                                                                                                                                },
                                                                                                                              }
                                                                                                                              let l80 = i32::from(*base.add(48+12*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                              match l80 {
                                                                                                                                0 => (),
                                                                                                                                _ => {
                                                                                                                                  let l81 = *base.add(48+13*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                  let l82 = *base.add(48+14*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                  _rt::cabi_dealloc(l81, l82, 1);
                                                                                                                                  let l83 = i32::from(*base.add(64+16*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                                  match l83 {
                                                                                                                                    0 => (),
                                                                                                                                    _ => {
                                                                                                                                      let l84 = *base.add(64+17*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                      let l85 = *base.add(64+18*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                      _rt::cabi_dealloc(l84, l85, 1);
                                                                                                                                    },
                                                                                                                                  }
                                                                                                                                },
                                                                                                                              }
                                                                                                                              let l86 = i32::from(*base.add(64+19*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                              match l86 {
                                                                                                                                0 => (),
                                                                                                                                _ => {
                                                                                                                                  let l87 = *base.add(64+20*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                  let l88 = *base.add(64+21*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                  _rt::cabi_dealloc(l87, l88, 1);
                                                                                                                                  let l89 = i32::from(*base.add(80+23*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                                  match l89 {
                                                                                                                                    0 => (),
                                                                                                                                    _ => {
                                                                                                                                      let l90 = *base.add(80+24*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                      let l91 = *base.add(80+25*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                      _rt::cabi_dealloc(l90, l91, 1);
                                                                                                                                    },
                                                                                                                                  }
                                                                                                                                },
                                                                                                                              }
                                                                                                                              let l92 = i32::from(*base.add(80+26*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                              match l92 {
                                                                                                                                0 => (),
                                                                                                                                _ => {
                                                                                                                                  let l93 = *base.add(80+27*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                  let l94 = *base.add(80+28*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                  _rt::cabi_dealloc(l93, l94, 1);
                                                                                                                                  let l95 = i32::from(*base.add(96+30*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                                  match l95 {
                                                                                                                                    0 => (),
                                                                                                                                    _ => {
                                                                                                                                      let l96 = *base.add(96+31*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                      let l97 = *base.add(96+32*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                      _rt::cabi_dealloc(l96, l97, 1);
                                                                                                                                    },
                                                                                                                                  }
                                                                                                                                },
                                                                                                                              }
                                                                                                                              let l98 = i32::from(*base.add(96+33*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                              match l98 {
                                                                                                                                0 => (),
                                                                                                                                _ => {
                                                                                                                                  let l99 = *base.add(96+34*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                  let l100 = *base.add(96+35*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                  _rt::cabi_dealloc(l99, l100, 1);
                                                                                                                                  let l101 = i32::from(*base.add(112+37*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                                  match l101 {
                                                                                                                                    0 => (),
                                                                                                                                    _ => {
                                                                                                                                      let l102 = *base.add(112+38*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                      let l103 = *base.add(112+39*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                      _rt::cabi_dealloc(l102, l103, 1);
                                                                                                                                    },
                                                                                                                                  }
                                                                                                                                },
                                                                                                                              }
                                                                                                                            },
                                                                                                                          }
                                                                                                                          let l104 = i32::from(*base.add(112+40*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                          match l104 {
                                                                                                                            0 => (),
                                                                                                                            _ => {
                                                                                                                              let l105 = *base.add(112+41*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                              let l106 = *base.add(112+42*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                              _rt::cabi_dealloc(l105, l106, 1);
                                                                                                                            },
                                                                                                                          }
                                                                                                                          let l107 = i32::from(*base.add(112+43*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                          match l107 {
                                                                                                                            0 => (),
                                                                                                                            _ => {
                                                                                                                              let l108 = *base.add(112+44*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                              let l109 = *base.add(112+45*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                              _rt::cabi_dealloc(l108, l109, 1);
                                                                                                                            },
                                                                                                                          }
                                                                                                                          let l110 = i32::from(*base.add(120+46*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                          match l110 {
                                                                                                                            0 => (),
                                                                                                                            _ => {
                                                                                                                              let l111 = *base.add(120+47*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                              let l112 = *base.add(120+48*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                              _rt::cabi_dealloc(l111, l112, 1);
                                                                                                                            },
                                                                                                                          }
                                                                                                                          let l113 = *base.add(120+49*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                          let l114 = *base.add(120+50*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          let base117 = l113;
                                                                                                                          let len117 = l114;
                                                                                                                          for i in 0..len117 {
                                                                                                                            let base = base117.add(i * (2*::core::mem::size_of::<*const u8>()));
                                                                                                                            {
                                                                                                                              let l115 = *base.add(0).cast::<*mut u8>();
                                                                                                                              let l116 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                              _rt::cabi_dealloc(l115, l116, 1);
                                                                                                                            }
                                                                                                                          }
                                                                                                                          _rt::cabi_dealloc(base117, len117 * (2*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                                                                                                          let l118 = *base.add(120+51*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                          let l119 = *base.add(120+52*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          let base124 = l118;
                                                                                                                          let len124 = l119;
                                                                                                                          for i in 0..len124 {
                                                                                                                            let base = base124.add(i * (4*::core::mem::size_of::<*const u8>()));
                                                                                                                            {
                                                                                                                              let l120 = *base.add(0).cast::<*mut u8>();
                                                                                                                              let l121 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                              _rt::cabi_dealloc(l120, l121, 1);
                                                                                                                              let l122 = *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                              let l123 = *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                              _rt::cabi_dealloc(l122, l123, 1);
                                                                                                                            }
                                                                                                                          }
                                                                                                                          _rt::cabi_dealloc(base124, len124 * (4*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                                                                                                        }
                                                                                                                      }
                                                                                                                      _rt::cabi_dealloc(base125, len125 * (128+52*::core::mem::size_of::<*const u8>()), 8);
                                                                                                                    }
                                                                                                                  }
                                                                                                                  _rt::cabi_dealloc(base126, len126 * (24+6*::core::mem::size_of::<*const u8>()), 8);
                                                                                                                  let l127 = *arg0.add(120+62*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                  let l128 = *arg0.add(120+63*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                  let base170 = l127;
                                                                                                                  let len170 = l128;
                                                                                                                  for i in 0..len170 {
                                                                                                                    let base = base170.add(i * (80+46*::core::mem::size_of::<*const u8>()));
                                                                                                                    {
                                                                                                                      let l129 = *base.add(0).cast::<*mut u8>();
                                                                                                                      let l130 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      _rt::cabi_dealloc(l129, l130, 1);
                                                                                                                      let l131 = *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                      let l132 = *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      _rt::cabi_dealloc(l131, l132, 1);
                                                                                                                      let l133 = i32::from(*base.add(4*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                      match l133 {
                                                                                                                        0 => (),
                                                                                                                        _ => {
                                                                                                                          let l134 = i32::from(*base.add(5*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                          match l134 {
                                                                                                                            0 => (),
                                                                                                                            _ => {
                                                                                                                              let l135 = *base.add(6*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                              let l136 = *base.add(7*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                              _rt::cabi_dealloc(l135, l136, 1);
                                                                                                                              let l137 = i32::from(*base.add(16+9*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                              match l137 {
                                                                                                                                0 => (),
                                                                                                                                _ => {
                                                                                                                                  let l138 = *base.add(16+10*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                  let l139 = *base.add(16+11*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                  _rt::cabi_dealloc(l138, l139, 1);
                                                                                                                                },
                                                                                                                              }
                                                                                                                            },
                                                                                                                          }
                                                                                                                          let l140 = i32::from(*base.add(16+12*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                          match l140 {
                                                                                                                            0 => (),
                                                                                                                            _ => {
                                                                                                                              let l141 = *base.add(16+13*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                              let l142 = *base.add(16+14*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                              _rt::cabi_dealloc(l141, l142, 1);
                                                                                                                              let l143 = i32::from(*base.add(32+16*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                              match l143 {
                                                                                                                                0 => (),
                                                                                                                                _ => {
                                                                                                                                  let l144 = *base.add(32+17*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                  let l145 = *base.add(32+18*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                  _rt::cabi_dealloc(l144, l145, 1);
                                                                                                                                },
                                                                                                                              }
                                                                                                                            },
                                                                                                                          }
                                                                                                                          let l146 = i32::from(*base.add(32+19*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                          match l146 {
                                                                                                                            0 => (),
                                                                                                                            _ => {
                                                                                                                              let l147 = *base.add(32+20*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                              let l148 = *base.add(32+21*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                              _rt::cabi_dealloc(l147, l148, 1);
                                                                                                                              let l149 = i32::from(*base.add(48+23*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                              match l149 {
                                                                                                                                0 => (),
                                                                                                                                _ => {
                                                                                                                                  let l150 = *base.add(48+24*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                  let l151 = *base.add(48+25*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                  _rt::cabi_dealloc(l150, l151, 1);
                                                                                                                                },
                                                                                                                              }
                                                                                                                            },
                                                                                                                          }
                                                                                                                          let l152 = i32::from(*base.add(48+26*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                          match l152 {
                                                                                                                            0 => (),
                                                                                                                            _ => {
                                                                                                                              let l153 = *base.add(48+27*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                              let l154 = *base.add(48+28*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                              _rt::cabi_dealloc(l153, l154, 1);
                                                                                                                              let l155 = i32::from(*base.add(64+30*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                              match l155 {
                                                                                                                                0 => (),
                                                                                                                                _ => {
                                                                                                                                  let l156 = *base.add(64+31*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                  let l157 = *base.add(64+32*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                  _rt::cabi_dealloc(l156, l157, 1);
                                                                                                                                },
                                                                                                                              }
                                                                                                                            },
                                                                                                                          }
                                                                                                                          let l158 = i32::from(*base.add(64+33*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                          match l158 {
                                                                                                                            0 => (),
                                                                                                                            _ => {
                                                                                                                              let l159 = *base.add(64+34*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                              let l160 = *base.add(64+35*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                              _rt::cabi_dealloc(l159, l160, 1);
                                                                                                                              let l161 = i32::from(*base.add(80+37*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                              match l161 {
                                                                                                                                0 => (),
                                                                                                                                _ => {
                                                                                                                                  let l162 = *base.add(80+38*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                  let l163 = *base.add(80+39*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                  _rt::cabi_dealloc(l162, l163, 1);
                                                                                                                                },
                                                                                                                              }
                                                                                                                            },
                                                                                                                          }
                                                                                                                        },
                                                                                                                      }
                                                                                                                      let l164 = i32::from(*base.add(80+40*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                      match l164 {
                                                                                                                        0 => (),
                                                                                                                        _ => {
                                                                                                                          let l165 = *base.add(80+41*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                          let l166 = *base.add(80+42*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          _rt::cabi_dealloc(l165, l166, 1);
                                                                                                                        },
                                                                                                                      }
                                                                                                                      let l167 = i32::from(*base.add(80+43*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                      match l167 {
                                                                                                                        0 => (),
                                                                                                                        _ => {
                                                                                                                          let l168 = *base.add(80+44*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                          let l169 = *base.add(80+45*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          _rt::cabi_dealloc(l168, l169, 1);
                                                                                                                        },
                                                                                                                      }
                                                                                                                    }
                                                                                                                  }
                                                                                                                  _rt::cabi_dealloc(base170, len170 * (80+46*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                                                                                                  let l171 = *arg0.add(120+64*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                  let l172 = *arg0.add(120+65*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                  let base214 = l171;
                                                                                                                  let len214 = l172;
                                                                                                                  for i in 0..len214 {
                                                                                                                    let base = base214.add(i * (80+46*::core::mem::size_of::<*const u8>()));
                                                                                                                    {
                                                                                                                      let l173 = *base.add(0).cast::<*mut u8>();
                                                                                                                      let l174 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      _rt::cabi_dealloc(l173, l174, 1);
                                                                                                                      let l175 = *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                      let l176 = *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      _rt::cabi_dealloc(l175, l176, 1);
                                                                                                                      let l177 = i32::from(*base.add(4*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                      match l177 {
                                                                                                                        0 => (),
                                                                                                                        _ => {
                                                                                                                          let l178 = i32::from(*base.add(5*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                          match l178 {
                                                                                                                            0 => (),
                                                                                                                            _ => {
                                                                                                                              let l179 = *base.add(6*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                              let l180 = *base.add(7*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                              _rt::cabi_dealloc(l179, l180, 1);
                                                                                                                              let l181 = i32::from(*base.add(16+9*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                              match l181 {
                                                                                                                                0 => (),
                                                                                                                                _ => {
                                                                                                                                  let l182 = *base.add(16+10*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                  let l183 = *base.add(16+11*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                  _rt::cabi_dealloc(l182, l183, 1);
                                                                                                                                },
                                                                                                                              }
                                                                                                                            },
                                                                                                                          }
                                                                                                                          let l184 = i32::from(*base.add(16+12*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                          match l184 {
                                                                                                                            0 => (),
                                                                                                                            _ => {
                                                                                                                              let l185 = *base.add(16+13*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                              let l186 = *base.add(16+14*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                              _rt::cabi_dealloc(l185, l186, 1);
                                                                                                                              let l187 = i32::from(*base.add(32+16*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                              match l187 {
                                                                                                                                0 => (),
                                                                                                                                _ => {
                                                                                                                                  let l188 = *base.add(32+17*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                  let l189 = *base.add(32+18*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                  _rt::cabi_dealloc(l188, l189, 1);
                                                                                                                                },
                                                                                                                              }
                                                                                                                            },
                                                                                                                          }
                                                                                                                          let l190 = i32::from(*base.add(32+19*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                          match l190 {
                                                                                                                            0 => (),
                                                                                                                            _ => {
                                                                                                                              let l191 = *base.add(32+20*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                              let l192 = *base.add(32+21*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                              _rt::cabi_dealloc(l191, l192, 1);
                                                                                                                              let l193 = i32::from(*base.add(48+23*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                              match l193 {
                                                                                                                                0 => (),
                                                                                                                                _ => {
                                                                                                                                  let l194 = *base.add(48+24*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                  let l195 = *base.add(48+25*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                  _rt::cabi_dealloc(l194, l195, 1);
                                                                                                                                },
                                                                                                                              }
                                                                                                                            },
                                                                                                                          }
                                                                                                                          let l196 = i32::from(*base.add(48+26*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                          match l196 {
                                                                                                                            0 => (),
                                                                                                                            _ => {
                                                                                                                              let l197 = *base.add(48+27*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                              let l198 = *base.add(48+28*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                              _rt::cabi_dealloc(l197, l198, 1);
                                                                                                                              let l199 = i32::from(*base.add(64+30*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                              match l199 {
                                                                                                                                0 => (),
                                                                                                                                _ => {
                                                                                                                                  let l200 = *base.add(64+31*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                  let l201 = *base.add(64+32*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                  _rt::cabi_dealloc(l200, l201, 1);
                                                                                                                                },
                                                                                                                              }
                                                                                                                            },
                                                                                                                          }
                                                                                                                          let l202 = i32::from(*base.add(64+33*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                          match l202 {
                                                                                                                            0 => (),
                                                                                                                            _ => {
                                                                                                                              let l203 = *base.add(64+34*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                              let l204 = *base.add(64+35*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                              _rt::cabi_dealloc(l203, l204, 1);
                                                                                                                              let l205 = i32::from(*base.add(80+37*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                              match l205 {
                                                                                                                                0 => (),
                                                                                                                                _ => {
                                                                                                                                  let l206 = *base.add(80+38*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                  let l207 = *base.add(80+39*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                  _rt::cabi_dealloc(l206, l207, 1);
                                                                                                                                },
                                                                                                                              }
                                                                                                                            },
                                                                                                                          }
                                                                                                                        },
                                                                                                                      }
                                                                                                                      let l208 = i32::from(*base.add(80+40*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                      match l208 {
                                                                                                                        0 => (),
                                                                                                                        _ => {
                                                                                                                          let l209 = *base.add(80+41*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                          let l210 = *base.add(80+42*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          _rt::cabi_dealloc(l209, l210, 1);
                                                                                                                        },
                                                                                                                      }
                                                                                                                      let l211 = i32::from(*base.add(80+43*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                      match l211 {
                                                                                                                        0 => (),
                                                                                                                        _ => {
                                                                                                                          let l212 = *base.add(80+44*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                          let l213 = *base.add(80+45*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          _rt::cabi_dealloc(l212, l213, 1);
                                                                                                                        },
                                                                                                                      }
                                                                                                                    }
                                                                                                                  }
                                                                                                                  _rt::cabi_dealloc(base214, len214 * (80+46*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                                                                                                  let l215 = i32::from(*arg0.add(128+66*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                  match l215 {
                                                                                                                    0 => (),
                                                                                                                    _ => {
                                                                                                                      let l216 = *arg0.add(128+67*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                      let l217 = *arg0.add(128+68*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      _rt::cabi_dealloc(l216, l217, 1);
                                                                                                                    },
                                                                                                                  }
                                                                                                                  let l218 = *arg0.add(128+69*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                  let l219 = *arg0.add(128+70*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                  let base224 = l218;
                                                                                                                  let len224 = l219;
                                                                                                                  for i in 0..len224 {
                                                                                                                    let base = base224.add(i * (4*::core::mem::size_of::<*const u8>()));
                                                                                                                    {
                                                                                                                      let l220 = *base.add(0).cast::<*mut u8>();
                                                                                                                      let l221 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      _rt::cabi_dealloc(l220, l221, 1);
                                                                                                                      let l222 = *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                      let l223 = *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      _rt::cabi_dealloc(l222, l223, 1);
                                                                                                                    }
                                                                                                                  }
                                                                                                                  _rt::cabi_dealloc(base224, len224 * (4*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                                                                                                  let l225 = i32::from(*arg0.add(128+71*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                  match l225 {
                                                                                                                    0 => (),
                                                                                                                    _ => {
                                                                                                                      let l226 = *arg0.add(128+72*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                      let l227 = *arg0.add(128+73*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      _rt::cabi_dealloc(l226, l227, 1);
                                                                                                                    },
                                                                                                                  }
                                                                                                                  let l228 = i32::from(*arg0.add(128+74*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                  match l228 {
                                                                                                                    0 => (),
                                                                                                                    _ => {
                                                                                                                      let l229 = *arg0.add(128+75*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                      let l230 = *arg0.add(128+76*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      _rt::cabi_dealloc(l229, l230, 1);
                                                                                                                    },
                                                                                                                  }
                                                                                                                  let l231 = i32::from(*arg0.add(128+77*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                  match l231 {
                                                                                                                    0 => (),
                                                                                                                    _ => {
                                                                                                                      let l232 = *arg0.add(128+78*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                      let l233 = *arg0.add(128+79*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      _rt::cabi_dealloc(l232, l233, 1);
                                                                                                                    },
                                                                                                                  }
                                                                                                                  let l234 = i32::from(*arg0.add(128+80*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                  match l234 {
                                                                                                                    0 => (),
                                                                                                                    _ => {
                                                                                                                      let l235 = *arg0.add(128+81*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                      let l236 = *arg0.add(128+82*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      _rt::cabi_dealloc(l235, l236, 1);
                                                                                                                    },
                                                                                                                  }
                                                                                                                  let l237 = *arg0.add(128+83*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                  let l238 = *arg0.add(128+84*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                  let base243 = l237;
                                                                                                                  let len243 = l238;
                                                                                                                  for i in 0..len243 {
                                                                                                                    let base = base243.add(i * (4*::core::mem::size_of::<*const u8>()));
                                                                                                                    {
                                                                                                                      let l239 = *base.add(0).cast::<*mut u8>();
                                                                                                                      let l240 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      _rt::cabi_dealloc(l239, l240, 1);
                                                                                                                      let l241 = *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                      let l242 = *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      _rt::cabi_dealloc(l241, l242, 1);
                                                                                                                    }
                                                                                                                  }
                                                                                                                  _rt::cabi_dealloc(base243, len243 * (4*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                                                                                                },
                                                                                                                _ => {
                                                                                                                  let l244 = i32::from(*arg0.add(8).cast::<u8>());
                                                                                                                  match l244 {
                                                                                                                    0 => {
                                                                                                                      let l245 = *arg0.add(8+1*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                      let l246 = *arg0.add(8+2*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      _rt::cabi_dealloc(l245, l246, 1);
                                                                                                                    },
                                                                                                                    1 => {
                                                                                                                      let l247 = *arg0.add(8+1*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                      let l248 = *arg0.add(8+2*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      _rt::cabi_dealloc(l247, l248, 1);
                                                                                                                    },
                                                                                                                    2 => (),
                                                                                                                    3 => (),
                                                                                                                    4 => (),
                                                                                                                    5 => (),
                                                                                                                    6 => (),
                                                                                                                    7 => (),
                                                                                                                    8 => (),
                                                                                                                    9 => {
                                                                                                                      let l249 = *arg0.add(8+1*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                      let l250 = *arg0.add(8+2*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      _rt::cabi_dealloc(l249, l250, 1);
                                                                                                                    },
                                                                                                                    _ => {
                                                                                                                      let l251 = *arg0.add(8+1*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                      let l252 = *arg0.add(8+2*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      _rt::cabi_dealloc(l251, l252, 1);
                                                                                                                    },
                                                                                                                  }
                                                                                                                },
                                                                                                              }
                                                                                                            } }
                                                                                                            #[doc(hidden)]
                                                                                                            #[allow(non_snake_case, unused_unsafe)]
                                                                                                            pub unsafe fn _export_get_servers_cabi<T_: Guest>(arg0: *mut u8,arg1: usize,arg2: i32,arg3: *mut u8,arg4: usize,arg5: i32,arg6: *mut u8,arg7: usize,arg8: i32,arg9: *mut u8,arg10: usize,arg11: *mut u8,arg12: usize,) -> *mut u8 { unsafe {#[cfg(target_arch="wasm32")]
                                                                                                            _rt::run_ctors_once();let result8 = {
                                                                                                              let len0 = arg1;
                                                                                                              let bytes0 = _rt::Vec::from_raw_parts(arg0.cast(), len0, len0);
                                                                                                              let base6 = arg9;
                                                                                                              let len6 = arg10;
                                                                                                              let mut result6 = _rt::Vec::with_capacity(len6);
                                                                                                              for i in 0..len6 {
                                                                                                                let base = base6.add(i * (2*::core::mem::size_of::<*const u8>()));
                                                                                                                let e6 = {
                                                                                                                  let l3 = *base.add(0).cast::<*mut u8>();
                                                                                                                  let l4 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                  let len5 = l4;
                                                                                                                  let bytes5 = _rt::Vec::from_raw_parts(l3.cast(), len5, len5);

                                                                                                                  _rt::string_lift(bytes5)
                                                                                                                };
                                                                                                                result6.push(e6);
                                                                                                              }
                                                                                                              _rt::cabi_dealloc(base6, len6 * (2*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                                                                                              let len7 = arg12;
                                                                                                              let bytes7 = _rt::Vec::from_raw_parts(arg11.cast(), len7, len7);
                                                                                                              T_::get_servers(super::super::bex::plugin::common::RequestContext{
                                                                                                                request_id: _rt::string_lift(bytes0),
                                                                                                                locale: match arg2 {
                                                                                                                  0 => None,
                                                                                                                  1 => {
                                                                                                                    let e = {
                                                                                                                      let len1 = arg4;
                                                                                                                      let bytes1 = _rt::Vec::from_raw_parts(arg3.cast(), len1, len1);

                                                                                                                      _rt::string_lift(bytes1)
                                                                                                                    };
                                                                                                                    Some(e)
                                                                                                                  }
                                                                                                                  _ => _rt::invalid_enum_discriminant(),
                                                                                                                },
                                                                                                                region: match arg5 {
                                                                                                                  0 => None,
                                                                                                                  1 => {
                                                                                                                    let e = {
                                                                                                                      let len2 = arg7;
                                                                                                                      let bytes2 = _rt::Vec::from_raw_parts(arg6.cast(), len2, len2);

                                                                                                                      _rt::string_lift(bytes2)
                                                                                                                    };
                                                                                                                    Some(e)
                                                                                                                  }
                                                                                                                  _ => _rt::invalid_enum_discriminant(),
                                                                                                                },
                                                                                                                safe_mode: _rt::bool_lift(arg8 as u8),
                                                                                                                hints: result6,
                                                                                                              }, _rt::string_lift(bytes7))
                                                                                                            };
                                                                                                            let ptr9 = (&raw mut _RET_AREA.0).cast::<u8>();
                                                                                                            match result8 {
                                                                                                              Ok(e) => { {
                                                                                                                *ptr9.add(0).cast::<u8>() = (0i32) as u8;
                                                                                                                let vec18 = e;
                                                                                                                let len18 = vec18.len();
                                                                                                                let layout18 = _rt::alloc::Layout::from_size_align(vec18.len() * (9*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>()).unwrap();
                                                                                                                let (result18, _cleanup18) = wit_bindgen::rt::Cleanup::new(layout18);if let Some(cleanup) = _cleanup18 { cleanup.forget(); }
                                                                                                                for (i, e) in vec18.into_iter().enumerate() {
                                                                                                                  let base = result18.add(i * (9*::core::mem::size_of::<*const u8>()));
                                                                                                                  {
                                                                                                                    let super::super::bex::plugin::common::Server{ id:id10, label:label10, url:url10, priority:priority10, extra:extra10, } = e;
                                                                                                                    let vec11 = (id10.into_bytes()).into_boxed_slice();
                                                                                                                    let ptr11 = vec11.as_ptr().cast::<u8>();
                                                                                                                    let len11 = vec11.len();
                                                                                                                    ::core::mem::forget(vec11);
                                                                                                                    *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len11;
                                                                                                                    *base.add(0).cast::<*mut u8>() = ptr11.cast_mut();
                                                                                                                    let vec12 = (label10.into_bytes()).into_boxed_slice();
                                                                                                                    let ptr12 = vec12.as_ptr().cast::<u8>();
                                                                                                                    let len12 = vec12.len();
                                                                                                                    ::core::mem::forget(vec12);
                                                                                                                    *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len12;
                                                                                                                    *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr12.cast_mut();
                                                                                                                    let vec13 = (url10.into_bytes()).into_boxed_slice();
                                                                                                                    let ptr13 = vec13.as_ptr().cast::<u8>();
                                                                                                                    let len13 = vec13.len();
                                                                                                                    ::core::mem::forget(vec13);
                                                                                                                    *base.add(5*::core::mem::size_of::<*const u8>()).cast::<usize>() = len13;
                                                                                                                    *base.add(4*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr13.cast_mut();
                                                                                                                    *base.add(6*::core::mem::size_of::<*const u8>()).cast::<u8>() = (_rt::as_i32(priority10)) as u8;
                                                                                                                    let vec17 = extra10;
                                                                                                                    let len17 = vec17.len();
                                                                                                                    let layout17 = _rt::alloc::Layout::from_size_align(vec17.len() * (4*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>()).unwrap();
                                                                                                                    let (result17, _cleanup17) = wit_bindgen::rt::Cleanup::new(layout17);if let Some(cleanup) = _cleanup17 { cleanup.forget(); }
                                                                                                                    for (i, e) in vec17.into_iter().enumerate() {
                                                                                                                      let base = result17.add(i * (4*::core::mem::size_of::<*const u8>()));
                                                                                                                      {
                                                                                                                        let super::super::bex::plugin::common::Attr{ key:key14, value:value14, } = e;
                                                                                                                        let vec15 = (key14.into_bytes()).into_boxed_slice();
                                                                                                                        let ptr15 = vec15.as_ptr().cast::<u8>();
                                                                                                                        let len15 = vec15.len();
                                                                                                                        ::core::mem::forget(vec15);
                                                                                                                        *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len15;
                                                                                                                        *base.add(0).cast::<*mut u8>() = ptr15.cast_mut();
                                                                                                                        let vec16 = (value14.into_bytes()).into_boxed_slice();
                                                                                                                        let ptr16 = vec16.as_ptr().cast::<u8>();
                                                                                                                        let len16 = vec16.len();
                                                                                                                        ::core::mem::forget(vec16);
                                                                                                                        *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len16;
                                                                                                                        *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr16.cast_mut();
                                                                                                                      }
                                                                                                                    }
                                                                                                                    *base.add(8*::core::mem::size_of::<*const u8>()).cast::<usize>() = len17;
                                                                                                                    *base.add(7*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result17;
                                                                                                                  }
                                                                                                                }
                                                                                                                *ptr9.add(2*::core::mem::size_of::<*const u8>()).cast::<usize>() = len18;
                                                                                                                *ptr9.add(::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result18;
                                                                                                              } },
                                                                                                              Err(e) => { {
                                                                                                                *ptr9.add(0).cast::<u8>() = (1i32) as u8;
                                                                                                                use super::super::bex::plugin::common::PluginError as V23;
                                                                                                                match e {
                                                                                                                  V23::Network(e) => {
                                                                                                                    *ptr9.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                    let vec19 = (e.into_bytes()).into_boxed_slice();
                                                                                                                    let ptr19 = vec19.as_ptr().cast::<u8>();
                                                                                                                    let len19 = vec19.len();
                                                                                                                    ::core::mem::forget(vec19);
                                                                                                                    *ptr9.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len19;
                                                                                                                    *ptr9.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr19.cast_mut();
                                                                                                                  },
                                                                                                                  V23::Parse(e) => {
                                                                                                                    *ptr9.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                    let vec20 = (e.into_bytes()).into_boxed_slice();
                                                                                                                    let ptr20 = vec20.as_ptr().cast::<u8>();
                                                                                                                    let len20 = vec20.len();
                                                                                                                    ::core::mem::forget(vec20);
                                                                                                                    *ptr9.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len20;
                                                                                                                    *ptr9.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr20.cast_mut();
                                                                                                                  },
                                                                                                                  V23::NotFound=> {
                                                                                                                    {
                                                                                                                      *ptr9.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (2i32) as u8;
                                                                                                                    }
                                                                                                                  }
                                                                                                                  V23::Unauthorized=> {
                                                                                                                    {
                                                                                                                      *ptr9.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (3i32) as u8;
                                                                                                                    }
                                                                                                                  }
                                                                                                                  V23::Forbidden=> {
                                                                                                                    {
                                                                                                                      *ptr9.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (4i32) as u8;
                                                                                                                    }
                                                                                                                  }
                                                                                                                  V23::RateLimited(e) => {
                                                                                                                    *ptr9.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (5i32) as u8;
                                                                                                                    match e {
                                                                                                                      Some(e) => {
                                                                                                                        *ptr9.add(2*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                        *ptr9.add(4+2*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                                      },
                                                                                                                      None => {
                                                                                                                        {
                                                                                                                          *ptr9.add(2*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                        }
                                                                                                                      },
                                                                                                                    };},
                                                                                                                    V23::Timeout=> {
                                                                                                                      {
                                                                                                                        *ptr9.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (6i32) as u8;
                                                                                                                      }
                                                                                                                    }
                                                                                                                    V23::Cancelled=> {
                                                                                                                      {
                                                                                                                        *ptr9.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (7i32) as u8;
                                                                                                                      }
                                                                                                                    }
                                                                                                                    V23::Unsupported=> {
                                                                                                                      {
                                                                                                                        *ptr9.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (8i32) as u8;
                                                                                                                      }
                                                                                                                    }
                                                                                                                    V23::InvalidInput(e) => {
                                                                                                                      *ptr9.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (9i32) as u8;
                                                                                                                      let vec21 = (e.into_bytes()).into_boxed_slice();
                                                                                                                      let ptr21 = vec21.as_ptr().cast::<u8>();
                                                                                                                      let len21 = vec21.len();
                                                                                                                      ::core::mem::forget(vec21);
                                                                                                                      *ptr9.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len21;
                                                                                                                      *ptr9.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr21.cast_mut();
                                                                                                                    },
                                                                                                                    V23::Internal(e) => {
                                                                                                                      *ptr9.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (10i32) as u8;
                                                                                                                      let vec22 = (e.into_bytes()).into_boxed_slice();
                                                                                                                      let ptr22 = vec22.as_ptr().cast::<u8>();
                                                                                                                      let len22 = vec22.len();
                                                                                                                      ::core::mem::forget(vec22);
                                                                                                                      *ptr9.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len22;
                                                                                                                      *ptr9.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr22.cast_mut();
                                                                                                                    },
                                                                                                                  }
                                                                                                                } },
                                                                                                              };ptr9
                                                                                                            } }
                                                                                                            #[doc(hidden)]
                                                                                                            #[allow(non_snake_case)]
                                                                                                            pub unsafe fn __post_return_get_servers<T_: Guest>(arg0: *mut u8,) { unsafe {
                                                                                                              let l0 = i32::from(*arg0.add(0).cast::<u8>());
                                                                                                              match l0 {
                                                                                                                0 => {
                                                                                                                  let l1 = *arg0.add(::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                  let l2 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                  let base16 = l1;
                                                                                                                  let len16 = l2;
                                                                                                                  for i in 0..len16 {
                                                                                                                    let base = base16.add(i * (9*::core::mem::size_of::<*const u8>()));
                                                                                                                    {
                                                                                                                      let l3 = *base.add(0).cast::<*mut u8>();
                                                                                                                      let l4 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      _rt::cabi_dealloc(l3, l4, 1);
                                                                                                                      let l5 = *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                      let l6 = *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      _rt::cabi_dealloc(l5, l6, 1);
                                                                                                                      let l7 = *base.add(4*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                      let l8 = *base.add(5*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      _rt::cabi_dealloc(l7, l8, 1);
                                                                                                                      let l9 = *base.add(7*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                      let l10 = *base.add(8*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      let base15 = l9;
                                                                                                                      let len15 = l10;
                                                                                                                      for i in 0..len15 {
                                                                                                                        let base = base15.add(i * (4*::core::mem::size_of::<*const u8>()));
                                                                                                                        {
                                                                                                                          let l11 = *base.add(0).cast::<*mut u8>();
                                                                                                                          let l12 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          _rt::cabi_dealloc(l11, l12, 1);
                                                                                                                          let l13 = *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                          let l14 = *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          _rt::cabi_dealloc(l13, l14, 1);
                                                                                                                        }
                                                                                                                      }
                                                                                                                      _rt::cabi_dealloc(base15, len15 * (4*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                                                                                                    }
                                                                                                                  }
                                                                                                                  _rt::cabi_dealloc(base16, len16 * (9*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                                                                                                },
                                                                                                                _ => {
                                                                                                                  let l17 = i32::from(*arg0.add(::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                  match l17 {
                                                                                                                    0 => {
                                                                                                                      let l18 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                      let l19 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      _rt::cabi_dealloc(l18, l19, 1);
                                                                                                                    },
                                                                                                                    1 => {
                                                                                                                      let l20 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                      let l21 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      _rt::cabi_dealloc(l20, l21, 1);
                                                                                                                    },
                                                                                                                    2 => (),
                                                                                                                    3 => (),
                                                                                                                    4 => (),
                                                                                                                    5 => (),
                                                                                                                    6 => (),
                                                                                                                    7 => (),
                                                                                                                    8 => (),
                                                                                                                    9 => {
                                                                                                                      let l22 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                      let l23 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      _rt::cabi_dealloc(l22, l23, 1);
                                                                                                                    },
                                                                                                                    _ => {
                                                                                                                      let l24 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                      let l25 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      _rt::cabi_dealloc(l24, l25, 1);
                                                                                                                    },
                                                                                                                  }
                                                                                                                },
                                                                                                              }
                                                                                                            } }
                                                                                                            #[doc(hidden)]
                                                                                                            #[allow(non_snake_case, unused_unsafe)]
                                                                                                            pub unsafe fn _export_resolve_stream_cabi<T_: Guest>(arg0: *mut u8,) -> *mut u8 { unsafe {#[cfg(target_arch="wasm32")]
                                                                                                            _rt::run_ctors_once();let result37 = {
                                                                                                              let l0 = *arg0.add(0).cast::<*mut u8>();
                                                                                                              let l1 = *arg0.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                              let len2 = l1;
                                                                                                              let bytes2 = _rt::Vec::from_raw_parts(l0.cast(), len2, len2);
                                                                                                              let l3 = i32::from(*arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                              let l7 = i32::from(*arg0.add(5*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                              let l11 = i32::from(*arg0.add(8*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                              let l12 = *arg0.add(9*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                              let l13 = *arg0.add(10*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                              let base17 = l12;
                                                                                                              let len17 = l13;
                                                                                                              let mut result17 = _rt::Vec::with_capacity(len17);
                                                                                                              for i in 0..len17 {
                                                                                                                let base = base17.add(i * (2*::core::mem::size_of::<*const u8>()));
                                                                                                                let e17 = {
                                                                                                                  let l14 = *base.add(0).cast::<*mut u8>();
                                                                                                                  let l15 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                  let len16 = l15;
                                                                                                                  let bytes16 = _rt::Vec::from_raw_parts(l14.cast(), len16, len16);

                                                                                                                  _rt::string_lift(bytes16)
                                                                                                                };
                                                                                                                result17.push(e17);
                                                                                                              }
                                                                                                              _rt::cabi_dealloc(base17, len17 * (2*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                                                                                              let l18 = *arg0.add(11*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                              let l19 = *arg0.add(12*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                              let len20 = l19;
                                                                                                              let bytes20 = _rt::Vec::from_raw_parts(l18.cast(), len20, len20);
                                                                                                              let l21 = *arg0.add(13*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                              let l22 = *arg0.add(14*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                              let len23 = l22;
                                                                                                              let bytes23 = _rt::Vec::from_raw_parts(l21.cast(), len23, len23);
                                                                                                              let l24 = *arg0.add(15*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                              let l25 = *arg0.add(16*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                              let len26 = l25;
                                                                                                              let bytes26 = _rt::Vec::from_raw_parts(l24.cast(), len26, len26);
                                                                                                              let l27 = i32::from(*arg0.add(17*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                              let l28 = *arg0.add(18*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                              let l29 = *arg0.add(19*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                              let base36 = l28;
                                                                                                              let len36 = l29;
                                                                                                              let mut result36 = _rt::Vec::with_capacity(len36);
                                                                                                              for i in 0..len36 {
                                                                                                                let base = base36.add(i * (4*::core::mem::size_of::<*const u8>()));
                                                                                                                let e36 = {
                                                                                                                  let l30 = *base.add(0).cast::<*mut u8>();
                                                                                                                  let l31 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                  let len32 = l31;
                                                                                                                  let bytes32 = _rt::Vec::from_raw_parts(l30.cast(), len32, len32);
                                                                                                                  let l33 = *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                  let l34 = *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                  let len35 = l34;
                                                                                                                  let bytes35 = _rt::Vec::from_raw_parts(l33.cast(), len35, len35);

                                                                                                                  super::super::bex::plugin::common::Attr{
                                                                                                                    key: _rt::string_lift(bytes32),
                                                                                                                    value: _rt::string_lift(bytes35),
                                                                                                                  }
                                                                                                                };
                                                                                                                result36.push(e36);
                                                                                                              }
                                                                                                              _rt::cabi_dealloc(base36, len36 * (4*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                                                                                              T_::resolve_stream(super::super::bex::plugin::common::RequestContext{
                                                                                                                request_id: _rt::string_lift(bytes2),
                                                                                                                locale: match l3 {
                                                                                                                  0 => None,
                                                                                                                  1 => {
                                                                                                                    let e = {
                                                                                                                      let l4 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                      let l5 = *arg0.add(4*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      let len6 = l5;
                                                                                                                      let bytes6 = _rt::Vec::from_raw_parts(l4.cast(), len6, len6);

                                                                                                                      _rt::string_lift(bytes6)
                                                                                                                    };
                                                                                                                    Some(e)
                                                                                                                  }
                                                                                                                  _ => _rt::invalid_enum_discriminant(),
                                                                                                                },
                                                                                                                region: match l7 {
                                                                                                                  0 => None,
                                                                                                                  1 => {
                                                                                                                    let e = {
                                                                                                                      let l8 = *arg0.add(6*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                      let l9 = *arg0.add(7*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      let len10 = l9;
                                                                                                                      let bytes10 = _rt::Vec::from_raw_parts(l8.cast(), len10, len10);

                                                                                                                      _rt::string_lift(bytes10)
                                                                                                                    };
                                                                                                                    Some(e)
                                                                                                                  }
                                                                                                                  _ => _rt::invalid_enum_discriminant(),
                                                                                                                },
                                                                                                                safe_mode: _rt::bool_lift(l11 as u8),
                                                                                                                hints: result17,
                                                                                                              }, super::super::bex::plugin::common::Server{
                                                                                                                id: _rt::string_lift(bytes20),
                                                                                                                label: _rt::string_lift(bytes23),
                                                                                                                url: _rt::string_lift(bytes26),
                                                                                                                priority: l27 as u8,
                                                                                                                extra: result36,
                                                                                                              })
                                                                                                            };
                                                                                                            _rt::cabi_dealloc(arg0, 20*::core::mem::size_of::<*const u8>(), ::core::mem::size_of::<*const u8>());
                                                                                                            let ptr38 = (&raw mut _RET_AREA.0).cast::<u8>();
                                                                                                            match result37 {
                                                                                                              Ok(e) => { {
                                                                                                                *ptr38.add(0).cast::<u8>() = (0i32) as u8;
                                                                                                                let super::super::bex::plugin::common::StreamSource{ id:id39, label:label39, format:format39, manifest_url:manifest_url39, videos:videos39, subtitles:subtitles39, headers:headers39, extra:extra39, } = e;
                                                                                                                let vec40 = (id39.into_bytes()).into_boxed_slice();
                                                                                                                let ptr40 = vec40.as_ptr().cast::<u8>();
                                                                                                                let len40 = vec40.len();
                                                                                                                ::core::mem::forget(vec40);
                                                                                                                *ptr38.add(2*::core::mem::size_of::<*const u8>()).cast::<usize>() = len40;
                                                                                                                *ptr38.add(::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr40.cast_mut();
                                                                                                                let vec41 = (label39.into_bytes()).into_boxed_slice();
                                                                                                                let ptr41 = vec41.as_ptr().cast::<u8>();
                                                                                                                let len41 = vec41.len();
                                                                                                                ::core::mem::forget(vec41);
                                                                                                                *ptr38.add(4*::core::mem::size_of::<*const u8>()).cast::<usize>() = len41;
                                                                                                                *ptr38.add(3*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr41.cast_mut();
                                                                                                                *ptr38.add(5*::core::mem::size_of::<*const u8>()).cast::<u8>() = (format39.clone() as i32) as u8;
                                                                                                                match manifest_url39 {
                                                                                                                  Some(e) => {
                                                                                                                    *ptr38.add(6*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                    let vec42 = (e.into_bytes()).into_boxed_slice();
                                                                                                                    let ptr42 = vec42.as_ptr().cast::<u8>();
                                                                                                                    let len42 = vec42.len();
                                                                                                                    ::core::mem::forget(vec42);
                                                                                                                    *ptr38.add(8*::core::mem::size_of::<*const u8>()).cast::<usize>() = len42;
                                                                                                                    *ptr38.add(7*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr42.cast_mut();
                                                                                                                  },
                                                                                                                  None => {
                                                                                                                    {
                                                                                                                      *ptr38.add(6*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                    }
                                                                                                                  },
                                                                                                                };let vec49 = videos39;
                                                                                                                let len49 = vec49.len();
                                                                                                                let layout49 = _rt::alloc::Layout::from_size_align(vec49.len() * (32+10*::core::mem::size_of::<*const u8>()), 8).unwrap();
                                                                                                                let (result49, _cleanup49) = wit_bindgen::rt::Cleanup::new(layout49);if let Some(cleanup) = _cleanup49 { cleanup.forget(); }
                                                                                                                for (i, e) in vec49.into_iter().enumerate() {
                                                                                                                  let base = result49.add(i * (32+10*::core::mem::size_of::<*const u8>()));
                                                                                                                  {
                                                                                                                    let super::super::bex::plugin::common::VideoTrack{ resolution:resolution43, url:url43, mime_type:mime_type43, bitrate:bitrate43, codecs:codecs43, } = e;
                                                                                                                    let super::super::bex::plugin::common::VideoResolution{ width:width44, height:height44, hdr:hdr44, label:label44, } = resolution43;
                                                                                                                    *base.add(0).cast::<i32>() = _rt::as_i32(width44);
                                                                                                                    *base.add(4).cast::<i32>() = _rt::as_i32(height44);
                                                                                                                    *base.add(8).cast::<u8>() = (match hdr44 { true => 1, false => 0 }) as u8;
                                                                                                                    let vec45 = (label44.into_bytes()).into_boxed_slice();
                                                                                                                    let ptr45 = vec45.as_ptr().cast::<u8>();
                                                                                                                    let len45 = vec45.len();
                                                                                                                    ::core::mem::forget(vec45);
                                                                                                                    *base.add(8+2*::core::mem::size_of::<*const u8>()).cast::<usize>() = len45;
                                                                                                                    *base.add(8+1*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr45.cast_mut();
                                                                                                                    let vec46 = (url43.into_bytes()).into_boxed_slice();
                                                                                                                    let ptr46 = vec46.as_ptr().cast::<u8>();
                                                                                                                    let len46 = vec46.len();
                                                                                                                    ::core::mem::forget(vec46);
                                                                                                                    *base.add(8+4*::core::mem::size_of::<*const u8>()).cast::<usize>() = len46;
                                                                                                                    *base.add(8+3*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr46.cast_mut();
                                                                                                                    match mime_type43 {
                                                                                                                      Some(e) => {
                                                                                                                        *base.add(8+5*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                        let vec47 = (e.into_bytes()).into_boxed_slice();
                                                                                                                        let ptr47 = vec47.as_ptr().cast::<u8>();
                                                                                                                        let len47 = vec47.len();
                                                                                                                        ::core::mem::forget(vec47);
                                                                                                                        *base.add(8+7*::core::mem::size_of::<*const u8>()).cast::<usize>() = len47;
                                                                                                                        *base.add(8+6*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr47.cast_mut();
                                                                                                                      },
                                                                                                                      None => {
                                                                                                                        {
                                                                                                                          *base.add(8+5*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                        }
                                                                                                                      },
                                                                                                                    };match bitrate43 {
                                                                                                                      Some(e) => {
                                                                                                                        *base.add(8+8*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                        *base.add(16+8*::core::mem::size_of::<*const u8>()).cast::<i64>() = _rt::as_i64(e);
                                                                                                                      },
                                                                                                                      None => {
                                                                                                                        {
                                                                                                                          *base.add(8+8*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                        }
                                                                                                                      },
                                                                                                                    };match codecs43 {
                                                                                                                      Some(e) => {
                                                                                                                        *base.add(24+8*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                        let vec48 = (e.into_bytes()).into_boxed_slice();
                                                                                                                        let ptr48 = vec48.as_ptr().cast::<u8>();
                                                                                                                        let len48 = vec48.len();
                                                                                                                        ::core::mem::forget(vec48);
                                                                                                                        *base.add(24+10*::core::mem::size_of::<*const u8>()).cast::<usize>() = len48;
                                                                                                                        *base.add(24+9*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr48.cast_mut();
                                                                                                                      },
                                                                                                                      None => {
                                                                                                                        {
                                                                                                                          *base.add(24+8*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                        }
                                                                                                                      },
                                                                                                                    };}
                                                                                                                  }
                                                                                                                  *ptr38.add(10*::core::mem::size_of::<*const u8>()).cast::<usize>() = len49;
                                                                                                                  *ptr38.add(9*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result49;
                                                                                                                  let vec55 = subtitles39;
                                                                                                                  let len55 = vec55.len();
                                                                                                                  let layout55 = _rt::alloc::Layout::from_size_align(vec55.len() * (10*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>()).unwrap();
                                                                                                                  let (result55, _cleanup55) = wit_bindgen::rt::Cleanup::new(layout55);if let Some(cleanup) = _cleanup55 { cleanup.forget(); }
                                                                                                                  for (i, e) in vec55.into_iter().enumerate() {
                                                                                                                    let base = result55.add(i * (10*::core::mem::size_of::<*const u8>()));
                                                                                                                    {
                                                                                                                      let super::super::bex::plugin::common::SubtitleTrack{ label:label50, url:url50, language:language50, format:format50, } = e;
                                                                                                                      let vec51 = (label50.into_bytes()).into_boxed_slice();
                                                                                                                      let ptr51 = vec51.as_ptr().cast::<u8>();
                                                                                                                      let len51 = vec51.len();
                                                                                                                      ::core::mem::forget(vec51);
                                                                                                                      *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len51;
                                                                                                                      *base.add(0).cast::<*mut u8>() = ptr51.cast_mut();
                                                                                                                      let vec52 = (url50.into_bytes()).into_boxed_slice();
                                                                                                                      let ptr52 = vec52.as_ptr().cast::<u8>();
                                                                                                                      let len52 = vec52.len();
                                                                                                                      ::core::mem::forget(vec52);
                                                                                                                      *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len52;
                                                                                                                      *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr52.cast_mut();
                                                                                                                      match language50 {
                                                                                                                        Some(e) => {
                                                                                                                          *base.add(4*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                          let vec53 = (e.into_bytes()).into_boxed_slice();
                                                                                                                          let ptr53 = vec53.as_ptr().cast::<u8>();
                                                                                                                          let len53 = vec53.len();
                                                                                                                          ::core::mem::forget(vec53);
                                                                                                                          *base.add(6*::core::mem::size_of::<*const u8>()).cast::<usize>() = len53;
                                                                                                                          *base.add(5*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr53.cast_mut();
                                                                                                                        },
                                                                                                                        None => {
                                                                                                                          {
                                                                                                                            *base.add(4*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                          }
                                                                                                                        },
                                                                                                                      };match format50 {
                                                                                                                        Some(e) => {
                                                                                                                          *base.add(7*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                          let vec54 = (e.into_bytes()).into_boxed_slice();
                                                                                                                          let ptr54 = vec54.as_ptr().cast::<u8>();
                                                                                                                          let len54 = vec54.len();
                                                                                                                          ::core::mem::forget(vec54);
                                                                                                                          *base.add(9*::core::mem::size_of::<*const u8>()).cast::<usize>() = len54;
                                                                                                                          *base.add(8*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr54.cast_mut();
                                                                                                                        },
                                                                                                                        None => {
                                                                                                                          {
                                                                                                                            *base.add(7*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                          }
                                                                                                                        },
                                                                                                                      };}
                                                                                                                    }
                                                                                                                    *ptr38.add(12*::core::mem::size_of::<*const u8>()).cast::<usize>() = len55;
                                                                                                                    *ptr38.add(11*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result55;
                                                                                                                    let vec59 = headers39;
                                                                                                                    let len59 = vec59.len();
                                                                                                                    let layout59 = _rt::alloc::Layout::from_size_align(vec59.len() * (4*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>()).unwrap();
                                                                                                                    let (result59, _cleanup59) = wit_bindgen::rt::Cleanup::new(layout59);if let Some(cleanup) = _cleanup59 { cleanup.forget(); }
                                                                                                                    for (i, e) in vec59.into_iter().enumerate() {
                                                                                                                      let base = result59.add(i * (4*::core::mem::size_of::<*const u8>()));
                                                                                                                      {
                                                                                                                        let super::super::bex::plugin::common::Attr{ key:key56, value:value56, } = e;
                                                                                                                        let vec57 = (key56.into_bytes()).into_boxed_slice();
                                                                                                                        let ptr57 = vec57.as_ptr().cast::<u8>();
                                                                                                                        let len57 = vec57.len();
                                                                                                                        ::core::mem::forget(vec57);
                                                                                                                        *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len57;
                                                                                                                        *base.add(0).cast::<*mut u8>() = ptr57.cast_mut();
                                                                                                                        let vec58 = (value56.into_bytes()).into_boxed_slice();
                                                                                                                        let ptr58 = vec58.as_ptr().cast::<u8>();
                                                                                                                        let len58 = vec58.len();
                                                                                                                        ::core::mem::forget(vec58);
                                                                                                                        *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len58;
                                                                                                                        *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr58.cast_mut();
                                                                                                                      }
                                                                                                                    }
                                                                                                                    *ptr38.add(14*::core::mem::size_of::<*const u8>()).cast::<usize>() = len59;
                                                                                                                    *ptr38.add(13*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result59;
                                                                                                                    let vec63 = extra39;
                                                                                                                    let len63 = vec63.len();
                                                                                                                    let layout63 = _rt::alloc::Layout::from_size_align(vec63.len() * (4*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>()).unwrap();
                                                                                                                    let (result63, _cleanup63) = wit_bindgen::rt::Cleanup::new(layout63);if let Some(cleanup) = _cleanup63 { cleanup.forget(); }
                                                                                                                    for (i, e) in vec63.into_iter().enumerate() {
                                                                                                                      let base = result63.add(i * (4*::core::mem::size_of::<*const u8>()));
                                                                                                                      {
                                                                                                                        let super::super::bex::plugin::common::Attr{ key:key60, value:value60, } = e;
                                                                                                                        let vec61 = (key60.into_bytes()).into_boxed_slice();
                                                                                                                        let ptr61 = vec61.as_ptr().cast::<u8>();
                                                                                                                        let len61 = vec61.len();
                                                                                                                        ::core::mem::forget(vec61);
                                                                                                                        *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len61;
                                                                                                                        *base.add(0).cast::<*mut u8>() = ptr61.cast_mut();
                                                                                                                        let vec62 = (value60.into_bytes()).into_boxed_slice();
                                                                                                                        let ptr62 = vec62.as_ptr().cast::<u8>();
                                                                                                                        let len62 = vec62.len();
                                                                                                                        ::core::mem::forget(vec62);
                                                                                                                        *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len62;
                                                                                                                        *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr62.cast_mut();
                                                                                                                      }
                                                                                                                    }
                                                                                                                    *ptr38.add(16*::core::mem::size_of::<*const u8>()).cast::<usize>() = len63;
                                                                                                                    *ptr38.add(15*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result63;
                                                                                                                  } },
                                                                                                                  Err(e) => { {
                                                                                                                    *ptr38.add(0).cast::<u8>() = (1i32) as u8;
                                                                                                                    use super::super::bex::plugin::common::PluginError as V68;
                                                                                                                    match e {
                                                                                                                      V68::Network(e) => {
                                                                                                                        *ptr38.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                        let vec64 = (e.into_bytes()).into_boxed_slice();
                                                                                                                        let ptr64 = vec64.as_ptr().cast::<u8>();
                                                                                                                        let len64 = vec64.len();
                                                                                                                        ::core::mem::forget(vec64);
                                                                                                                        *ptr38.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len64;
                                                                                                                        *ptr38.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr64.cast_mut();
                                                                                                                      },
                                                                                                                      V68::Parse(e) => {
                                                                                                                        *ptr38.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                        let vec65 = (e.into_bytes()).into_boxed_slice();
                                                                                                                        let ptr65 = vec65.as_ptr().cast::<u8>();
                                                                                                                        let len65 = vec65.len();
                                                                                                                        ::core::mem::forget(vec65);
                                                                                                                        *ptr38.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len65;
                                                                                                                        *ptr38.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr65.cast_mut();
                                                                                                                      },
                                                                                                                      V68::NotFound=> {
                                                                                                                        {
                                                                                                                          *ptr38.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (2i32) as u8;
                                                                                                                        }
                                                                                                                      }
                                                                                                                      V68::Unauthorized=> {
                                                                                                                        {
                                                                                                                          *ptr38.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (3i32) as u8;
                                                                                                                        }
                                                                                                                      }
                                                                                                                      V68::Forbidden=> {
                                                                                                                        {
                                                                                                                          *ptr38.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (4i32) as u8;
                                                                                                                        }
                                                                                                                      }
                                                                                                                      V68::RateLimited(e) => {
                                                                                                                        *ptr38.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (5i32) as u8;
                                                                                                                        match e {
                                                                                                                          Some(e) => {
                                                                                                                            *ptr38.add(2*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                            *ptr38.add(4+2*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                                          },
                                                                                                                          None => {
                                                                                                                            {
                                                                                                                              *ptr38.add(2*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                            }
                                                                                                                          },
                                                                                                                        };},
                                                                                                                        V68::Timeout=> {
                                                                                                                          {
                                                                                                                            *ptr38.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (6i32) as u8;
                                                                                                                          }
                                                                                                                        }
                                                                                                                        V68::Cancelled=> {
                                                                                                                          {
                                                                                                                            *ptr38.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (7i32) as u8;
                                                                                                                          }
                                                                                                                        }
                                                                                                                        V68::Unsupported=> {
                                                                                                                          {
                                                                                                                            *ptr38.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (8i32) as u8;
                                                                                                                          }
                                                                                                                        }
                                                                                                                        V68::InvalidInput(e) => {
                                                                                                                          *ptr38.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (9i32) as u8;
                                                                                                                          let vec66 = (e.into_bytes()).into_boxed_slice();
                                                                                                                          let ptr66 = vec66.as_ptr().cast::<u8>();
                                                                                                                          let len66 = vec66.len();
                                                                                                                          ::core::mem::forget(vec66);
                                                                                                                          *ptr38.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len66;
                                                                                                                          *ptr38.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr66.cast_mut();
                                                                                                                        },
                                                                                                                        V68::Internal(e) => {
                                                                                                                          *ptr38.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (10i32) as u8;
                                                                                                                          let vec67 = (e.into_bytes()).into_boxed_slice();
                                                                                                                          let ptr67 = vec67.as_ptr().cast::<u8>();
                                                                                                                          let len67 = vec67.len();
                                                                                                                          ::core::mem::forget(vec67);
                                                                                                                          *ptr38.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len67;
                                                                                                                          *ptr38.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr67.cast_mut();
                                                                                                                        },
                                                                                                                      }
                                                                                                                    } },
                                                                                                                  };ptr38
                                                                                                                } }
                                                                                                                #[doc(hidden)]
                                                                                                                #[allow(non_snake_case)]
                                                                                                                pub unsafe fn __post_return_resolve_stream<T_: Guest>(arg0: *mut u8,) { unsafe {
                                                                                                                  let l0 = i32::from(*arg0.add(0).cast::<u8>());
                                                                                                                  match l0 {
                                                                                                                    0 => {
                                                                                                                      let l1 = *arg0.add(::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                      let l2 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      _rt::cabi_dealloc(l1, l2, 1);
                                                                                                                      let l3 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                      let l4 = *arg0.add(4*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      _rt::cabi_dealloc(l3, l4, 1);
                                                                                                                      let l5 = i32::from(*arg0.add(6*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                      match l5 {
                                                                                                                        0 => (),
                                                                                                                        _ => {
                                                                                                                          let l6 = *arg0.add(7*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                          let l7 = *arg0.add(8*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          _rt::cabi_dealloc(l6, l7, 1);
                                                                                                                        },
                                                                                                                      }
                                                                                                                      let l8 = *arg0.add(9*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                      let l9 = *arg0.add(10*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      let base20 = l8;
                                                                                                                      let len20 = l9;
                                                                                                                      for i in 0..len20 {
                                                                                                                        let base = base20.add(i * (32+10*::core::mem::size_of::<*const u8>()));
                                                                                                                        {
                                                                                                                          let l10 = *base.add(8+1*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                          let l11 = *base.add(8+2*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          _rt::cabi_dealloc(l10, l11, 1);
                                                                                                                          let l12 = *base.add(8+3*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                          let l13 = *base.add(8+4*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          _rt::cabi_dealloc(l12, l13, 1);
                                                                                                                          let l14 = i32::from(*base.add(8+5*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                          match l14 {
                                                                                                                            0 => (),
                                                                                                                            _ => {
                                                                                                                              let l15 = *base.add(8+6*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                              let l16 = *base.add(8+7*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                              _rt::cabi_dealloc(l15, l16, 1);
                                                                                                                            },
                                                                                                                          }
                                                                                                                          let l17 = i32::from(*base.add(24+8*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                          match l17 {
                                                                                                                            0 => (),
                                                                                                                            _ => {
                                                                                                                              let l18 = *base.add(24+9*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                              let l19 = *base.add(24+10*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                              _rt::cabi_dealloc(l18, l19, 1);
                                                                                                                            },
                                                                                                                          }
                                                                                                                        }
                                                                                                                      }
                                                                                                                      _rt::cabi_dealloc(base20, len20 * (32+10*::core::mem::size_of::<*const u8>()), 8);
                                                                                                                      let l21 = *arg0.add(11*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                      let l22 = *arg0.add(12*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      let base33 = l21;
                                                                                                                      let len33 = l22;
                                                                                                                      for i in 0..len33 {
                                                                                                                        let base = base33.add(i * (10*::core::mem::size_of::<*const u8>()));
                                                                                                                        {
                                                                                                                          let l23 = *base.add(0).cast::<*mut u8>();
                                                                                                                          let l24 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          _rt::cabi_dealloc(l23, l24, 1);
                                                                                                                          let l25 = *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                          let l26 = *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          _rt::cabi_dealloc(l25, l26, 1);
                                                                                                                          let l27 = i32::from(*base.add(4*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                          match l27 {
                                                                                                                            0 => (),
                                                                                                                            _ => {
                                                                                                                              let l28 = *base.add(5*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                              let l29 = *base.add(6*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                              _rt::cabi_dealloc(l28, l29, 1);
                                                                                                                            },
                                                                                                                          }
                                                                                                                          let l30 = i32::from(*base.add(7*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                          match l30 {
                                                                                                                            0 => (),
                                                                                                                            _ => {
                                                                                                                              let l31 = *base.add(8*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                              let l32 = *base.add(9*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                              _rt::cabi_dealloc(l31, l32, 1);
                                                                                                                            },
                                                                                                                          }
                                                                                                                        }
                                                                                                                      }
                                                                                                                      _rt::cabi_dealloc(base33, len33 * (10*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                                                                                                      let l34 = *arg0.add(13*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                      let l35 = *arg0.add(14*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      let base40 = l34;
                                                                                                                      let len40 = l35;
                                                                                                                      for i in 0..len40 {
                                                                                                                        let base = base40.add(i * (4*::core::mem::size_of::<*const u8>()));
                                                                                                                        {
                                                                                                                          let l36 = *base.add(0).cast::<*mut u8>();
                                                                                                                          let l37 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          _rt::cabi_dealloc(l36, l37, 1);
                                                                                                                          let l38 = *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                          let l39 = *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          _rt::cabi_dealloc(l38, l39, 1);
                                                                                                                        }
                                                                                                                      }
                                                                                                                      _rt::cabi_dealloc(base40, len40 * (4*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                                                                                                      let l41 = *arg0.add(15*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                      let l42 = *arg0.add(16*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      let base47 = l41;
                                                                                                                      let len47 = l42;
                                                                                                                      for i in 0..len47 {
                                                                                                                        let base = base47.add(i * (4*::core::mem::size_of::<*const u8>()));
                                                                                                                        {
                                                                                                                          let l43 = *base.add(0).cast::<*mut u8>();
                                                                                                                          let l44 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          _rt::cabi_dealloc(l43, l44, 1);
                                                                                                                          let l45 = *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                          let l46 = *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          _rt::cabi_dealloc(l45, l46, 1);
                                                                                                                        }
                                                                                                                      }
                                                                                                                      _rt::cabi_dealloc(base47, len47 * (4*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                                                                                                    },
                                                                                                                    _ => {
                                                                                                                      let l48 = i32::from(*arg0.add(::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                      match l48 {
                                                                                                                        0 => {
                                                                                                                          let l49 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                          let l50 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          _rt::cabi_dealloc(l49, l50, 1);
                                                                                                                        },
                                                                                                                        1 => {
                                                                                                                          let l51 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                          let l52 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          _rt::cabi_dealloc(l51, l52, 1);
                                                                                                                        },
                                                                                                                        2 => (),
                                                                                                                        3 => (),
                                                                                                                        4 => (),
                                                                                                                        5 => (),
                                                                                                                        6 => (),
                                                                                                                        7 => (),
                                                                                                                        8 => (),
                                                                                                                        9 => {
                                                                                                                          let l53 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                          let l54 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          _rt::cabi_dealloc(l53, l54, 1);
                                                                                                                        },
                                                                                                                        _ => {
                                                                                                                          let l55 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                          let l56 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          _rt::cabi_dealloc(l55, l56, 1);
                                                                                                                        },
                                                                                                                      }
                                                                                                                    },
                                                                                                                  }
                                                                                                                } }
                                                                                                                #[doc(hidden)]
                                                                                                                #[allow(non_snake_case, unused_unsafe)]
                                                                                                                pub unsafe fn _export_search_subtitles_cabi<T_: Guest>(arg0: *mut u8,) -> *mut u8 { unsafe {#[cfg(target_arch="wasm32")]
                                                                                                                _rt::run_ctors_once();let result49 = {
                                                                                                                  let l0 = *arg0.add(0).cast::<*mut u8>();
                                                                                                                  let l1 = *arg0.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                  let len2 = l1;
                                                                                                                  let bytes2 = _rt::Vec::from_raw_parts(l0.cast(), len2, len2);
                                                                                                                  let l3 = i32::from(*arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                  let l7 = i32::from(*arg0.add(5*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                  let l11 = i32::from(*arg0.add(8*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                  let l12 = *arg0.add(9*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                  let l13 = *arg0.add(10*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                  let base17 = l12;
                                                                                                                  let len17 = l13;
                                                                                                                  let mut result17 = _rt::Vec::with_capacity(len17);
                                                                                                                  for i in 0..len17 {
                                                                                                                    let base = base17.add(i * (2*::core::mem::size_of::<*const u8>()));
                                                                                                                    let e17 = {
                                                                                                                      let l14 = *base.add(0).cast::<*mut u8>();
                                                                                                                      let l15 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      let len16 = l15;
                                                                                                                      let bytes16 = _rt::Vec::from_raw_parts(l14.cast(), len16, len16);

                                                                                                                      _rt::string_lift(bytes16)
                                                                                                                    };
                                                                                                                    result17.push(e17);
                                                                                                                  }
                                                                                                                  _rt::cabi_dealloc(base17, len17 * (2*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                                                                                                  let l18 = i32::from(*arg0.add(8+10*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                  let l22 = i32::from(*arg0.add(8+13*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                  let l24 = i32::from(*arg0.add(16+13*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                  let l26 = i32::from(*arg0.add(24+13*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                  let l28 = i32::from(*arg0.add(32+13*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                  let l32 = i32::from(*arg0.add(32+16*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                  let l34 = i32::from(*arg0.add(40+16*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                  let l38 = i32::from(*arg0.add(48+18*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                  let l40 = *arg0.add(64+18*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                  let l41 = *arg0.add(64+19*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                  let base48 = l40;
                                                                                                                  let len48 = l41;
                                                                                                                  let mut result48 = _rt::Vec::with_capacity(len48);
                                                                                                                  for i in 0..len48 {
                                                                                                                    let base = base48.add(i * (4*::core::mem::size_of::<*const u8>()));
                                                                                                                    let e48 = {
                                                                                                                      let l42 = *base.add(0).cast::<*mut u8>();
                                                                                                                      let l43 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      let len44 = l43;
                                                                                                                      let bytes44 = _rt::Vec::from_raw_parts(l42.cast(), len44, len44);
                                                                                                                      let l45 = *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                      let l46 = *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      let len47 = l46;
                                                                                                                      let bytes47 = _rt::Vec::from_raw_parts(l45.cast(), len47, len47);

                                                                                                                      super::super::bex::plugin::common::LinkedId{
                                                                                                                        source: _rt::string_lift(bytes44),
                                                                                                                        id: _rt::string_lift(bytes47),
                                                                                                                      }
                                                                                                                    };
                                                                                                                    result48.push(e48);
                                                                                                                  }
                                                                                                                  _rt::cabi_dealloc(base48, len48 * (4*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                                                                                                  T_::search_subtitles(super::super::bex::plugin::common::RequestContext{
                                                                                                                    request_id: _rt::string_lift(bytes2),
                                                                                                                    locale: match l3 {
                                                                                                                      0 => None,
                                                                                                                      1 => {
                                                                                                                        let e = {
                                                                                                                          let l4 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                          let l5 = *arg0.add(4*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          let len6 = l5;
                                                                                                                          let bytes6 = _rt::Vec::from_raw_parts(l4.cast(), len6, len6);

                                                                                                                          _rt::string_lift(bytes6)
                                                                                                                        };
                                                                                                                        Some(e)
                                                                                                                      }
                                                                                                                      _ => _rt::invalid_enum_discriminant(),
                                                                                                                    },
                                                                                                                    region: match l7 {
                                                                                                                      0 => None,
                                                                                                                      1 => {
                                                                                                                        let e = {
                                                                                                                          let l8 = *arg0.add(6*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                          let l9 = *arg0.add(7*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          let len10 = l9;
                                                                                                                          let bytes10 = _rt::Vec::from_raw_parts(l8.cast(), len10, len10);

                                                                                                                          _rt::string_lift(bytes10)
                                                                                                                        };
                                                                                                                        Some(e)
                                                                                                                      }
                                                                                                                      _ => _rt::invalid_enum_discriminant(),
                                                                                                                    },
                                                                                                                    safe_mode: _rt::bool_lift(l11 as u8),
                                                                                                                    hints: result17,
                                                                                                                  }, super::super::bex::plugin::common::SubtitleQuery{
                                                                                                                    title: match l18 {
                                                                                                                      0 => None,
                                                                                                                      1 => {
                                                                                                                        let e = {
                                                                                                                          let l19 = *arg0.add(8+11*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                          let l20 = *arg0.add(8+12*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          let len21 = l20;
                                                                                                                          let bytes21 = _rt::Vec::from_raw_parts(l19.cast(), len21, len21);

                                                                                                                          _rt::string_lift(bytes21)
                                                                                                                        };
                                                                                                                        Some(e)
                                                                                                                      }
                                                                                                                      _ => _rt::invalid_enum_discriminant(),
                                                                                                                    },
                                                                                                                    year: match l22 {
                                                                                                                      0 => None,
                                                                                                                      1 => {
                                                                                                                        let e = {
                                                                                                                          let l23 = *arg0.add(12+13*::core::mem::size_of::<*const u8>()).cast::<i32>();

                                                                                                                          l23 as u32
                                                                                                                        };
                                                                                                                        Some(e)
                                                                                                                      }
                                                                                                                      _ => _rt::invalid_enum_discriminant(),
                                                                                                                    },
                                                                                                                    season: match l24 {
                                                                                                                      0 => None,
                                                                                                                      1 => {
                                                                                                                        let e = {
                                                                                                                          let l25 = *arg0.add(20+13*::core::mem::size_of::<*const u8>()).cast::<i32>();

                                                                                                                          l25 as u32
                                                                                                                        };
                                                                                                                        Some(e)
                                                                                                                      }
                                                                                                                      _ => _rt::invalid_enum_discriminant(),
                                                                                                                    },
                                                                                                                    episode: match l26 {
                                                                                                                      0 => None,
                                                                                                                      1 => {
                                                                                                                        let e = {
                                                                                                                          let l27 = *arg0.add(28+13*::core::mem::size_of::<*const u8>()).cast::<i32>();

                                                                                                                          l27 as u32
                                                                                                                        };
                                                                                                                        Some(e)
                                                                                                                      }
                                                                                                                      _ => _rt::invalid_enum_discriminant(),
                                                                                                                    },
                                                                                                                    language: match l28 {
                                                                                                                      0 => None,
                                                                                                                      1 => {
                                                                                                                        let e = {
                                                                                                                          let l29 = *arg0.add(32+14*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                          let l30 = *arg0.add(32+15*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          let len31 = l30;
                                                                                                                          let bytes31 = _rt::Vec::from_raw_parts(l29.cast(), len31, len31);

                                                                                                                          _rt::string_lift(bytes31)
                                                                                                                        };
                                                                                                                        Some(e)
                                                                                                                      }
                                                                                                                      _ => _rt::invalid_enum_discriminant(),
                                                                                                                    },
                                                                                                                    fps: match l32 {
                                                                                                                      0 => None,
                                                                                                                      1 => {
                                                                                                                        let e = {
                                                                                                                          let l33 = *arg0.add(36+16*::core::mem::size_of::<*const u8>()).cast::<f32>();

                                                                                                                          l33
                                                                                                                        };
                                                                                                                        Some(e)
                                                                                                                      }
                                                                                                                      _ => _rt::invalid_enum_discriminant(),
                                                                                                                    },
                                                                                                                    file_hash: match l34 {
                                                                                                                      0 => None,
                                                                                                                      1 => {
                                                                                                                        let e = {
                                                                                                                          let l35 = *arg0.add(40+17*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                          let l36 = *arg0.add(40+18*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          let len37 = l36;
                                                                                                                          let bytes37 = _rt::Vec::from_raw_parts(l35.cast(), len37, len37);

                                                                                                                          _rt::string_lift(bytes37)
                                                                                                                        };
                                                                                                                        Some(e)
                                                                                                                      }
                                                                                                                      _ => _rt::invalid_enum_discriminant(),
                                                                                                                    },
                                                                                                                    file_size: match l38 {
                                                                                                                      0 => None,
                                                                                                                      1 => {
                                                                                                                        let e = {
                                                                                                                          let l39 = *arg0.add(56+18*::core::mem::size_of::<*const u8>()).cast::<i64>();

                                                                                                                          l39 as u64
                                                                                                                        };
                                                                                                                        Some(e)
                                                                                                                      }
                                                                                                                      _ => _rt::invalid_enum_discriminant(),
                                                                                                                    },
                                                                                                                    identifiers: result48,
                                                                                                                  })
                                                                                                                };
                                                                                                                _rt::cabi_dealloc(arg0, 64+20*::core::mem::size_of::<*const u8>(), 8);
                                                                                                                let ptr50 = (&raw mut _RET_AREA.0).cast::<u8>();
                                                                                                                match result49 {
                                                                                                                  Ok(e) => { {
                                                                                                                    *ptr50.add(0).cast::<u8>() = (0i32) as u8;
                                                                                                                    let vec63 = e;
                                                                                                                    let len63 = vec63.len();
                                                                                                                    let layout63 = _rt::alloc::Layout::from_size_align(vec63.len() * (32+20*::core::mem::size_of::<*const u8>()), 8).unwrap();
                                                                                                                    let (result63, _cleanup63) = wit_bindgen::rt::Cleanup::new(layout63);if let Some(cleanup) = _cleanup63 { cleanup.forget(); }
                                                                                                                    for (i, e) in vec63.into_iter().enumerate() {
                                                                                                                      let base = result63.add(i * (32+20*::core::mem::size_of::<*const u8>()));
                                                                                                                      {
                                                                                                                        let super::super::bex::plugin::common::SubtitleEntry{ id:id51, title:title51, language:language51, format:format51, url:url51, release:release51, fps:fps51, downloads:downloads51, score:score51, hearing_impaired:hearing_impaired51, machine_translated:machine_translated51, file_hash:file_hash51, extra:extra51, } = e;
                                                                                                                        let vec52 = (id51.into_bytes()).into_boxed_slice();
                                                                                                                        let ptr52 = vec52.as_ptr().cast::<u8>();
                                                                                                                        let len52 = vec52.len();
                                                                                                                        ::core::mem::forget(vec52);
                                                                                                                        *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len52;
                                                                                                                        *base.add(0).cast::<*mut u8>() = ptr52.cast_mut();
                                                                                                                        let vec53 = (title51.into_bytes()).into_boxed_slice();
                                                                                                                        let ptr53 = vec53.as_ptr().cast::<u8>();
                                                                                                                        let len53 = vec53.len();
                                                                                                                        ::core::mem::forget(vec53);
                                                                                                                        *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len53;
                                                                                                                        *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr53.cast_mut();
                                                                                                                        let vec54 = (language51.into_bytes()).into_boxed_slice();
                                                                                                                        let ptr54 = vec54.as_ptr().cast::<u8>();
                                                                                                                        let len54 = vec54.len();
                                                                                                                        ::core::mem::forget(vec54);
                                                                                                                        *base.add(5*::core::mem::size_of::<*const u8>()).cast::<usize>() = len54;
                                                                                                                        *base.add(4*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr54.cast_mut();
                                                                                                                        let vec55 = (format51.into_bytes()).into_boxed_slice();
                                                                                                                        let ptr55 = vec55.as_ptr().cast::<u8>();
                                                                                                                        let len55 = vec55.len();
                                                                                                                        ::core::mem::forget(vec55);
                                                                                                                        *base.add(7*::core::mem::size_of::<*const u8>()).cast::<usize>() = len55;
                                                                                                                        *base.add(6*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr55.cast_mut();
                                                                                                                        match url51 {
                                                                                                                          Some(e) => {
                                                                                                                            *base.add(8*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                            let vec56 = (e.into_bytes()).into_boxed_slice();
                                                                                                                            let ptr56 = vec56.as_ptr().cast::<u8>();
                                                                                                                            let len56 = vec56.len();
                                                                                                                            ::core::mem::forget(vec56);
                                                                                                                            *base.add(10*::core::mem::size_of::<*const u8>()).cast::<usize>() = len56;
                                                                                                                            *base.add(9*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr56.cast_mut();
                                                                                                                          },
                                                                                                                          None => {
                                                                                                                            {
                                                                                                                              *base.add(8*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                            }
                                                                                                                          },
                                                                                                                        };match release51 {
                                                                                                                          Some(e) => {
                                                                                                                            *base.add(11*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                            let vec57 = (e.into_bytes()).into_boxed_slice();
                                                                                                                            let ptr57 = vec57.as_ptr().cast::<u8>();
                                                                                                                            let len57 = vec57.len();
                                                                                                                            ::core::mem::forget(vec57);
                                                                                                                            *base.add(13*::core::mem::size_of::<*const u8>()).cast::<usize>() = len57;
                                                                                                                            *base.add(12*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr57.cast_mut();
                                                                                                                          },
                                                                                                                          None => {
                                                                                                                            {
                                                                                                                              *base.add(11*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                            }
                                                                                                                          },
                                                                                                                        };match fps51 {
                                                                                                                          Some(e) => {
                                                                                                                            *base.add(14*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                            *base.add(4+14*::core::mem::size_of::<*const u8>()).cast::<f32>() = _rt::as_f32(e);
                                                                                                                          },
                                                                                                                          None => {
                                                                                                                            {
                                                                                                                              *base.add(14*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                            }
                                                                                                                          },
                                                                                                                        };match downloads51 {
                                                                                                                          Some(e) => {
                                                                                                                            *base.add(8+14*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                            *base.add(16+14*::core::mem::size_of::<*const u8>()).cast::<i64>() = _rt::as_i64(e);
                                                                                                                          },
                                                                                                                          None => {
                                                                                                                            {
                                                                                                                              *base.add(8+14*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                            }
                                                                                                                          },
                                                                                                                        };match score51 {
                                                                                                                          Some(e) => {
                                                                                                                            *base.add(24+14*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                            *base.add(28+14*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                                          },
                                                                                                                          None => {
                                                                                                                            {
                                                                                                                              *base.add(24+14*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                            }
                                                                                                                          },
                                                                                                                        };*base.add(32+14*::core::mem::size_of::<*const u8>()).cast::<u8>() = (match hearing_impaired51 { true => 1, false => 0 }) as u8;
                                                                                                                        *base.add(33+14*::core::mem::size_of::<*const u8>()).cast::<u8>() = (match machine_translated51 { true => 1, false => 0 }) as u8;
                                                                                                                        match file_hash51 {
                                                                                                                          Some(e) => {
                                                                                                                            *base.add(32+15*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                            let vec58 = (e.into_bytes()).into_boxed_slice();
                                                                                                                            let ptr58 = vec58.as_ptr().cast::<u8>();
                                                                                                                            let len58 = vec58.len();
                                                                                                                            ::core::mem::forget(vec58);
                                                                                                                            *base.add(32+17*::core::mem::size_of::<*const u8>()).cast::<usize>() = len58;
                                                                                                                            *base.add(32+16*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr58.cast_mut();
                                                                                                                          },
                                                                                                                          None => {
                                                                                                                            {
                                                                                                                              *base.add(32+15*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                            }
                                                                                                                          },
                                                                                                                        };let vec62 = extra51;
                                                                                                                        let len62 = vec62.len();
                                                                                                                        let layout62 = _rt::alloc::Layout::from_size_align(vec62.len() * (4*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>()).unwrap();
                                                                                                                        let (result62, _cleanup62) = wit_bindgen::rt::Cleanup::new(layout62);if let Some(cleanup) = _cleanup62 { cleanup.forget(); }
                                                                                                                        for (i, e) in vec62.into_iter().enumerate() {
                                                                                                                          let base = result62.add(i * (4*::core::mem::size_of::<*const u8>()));
                                                                                                                          {
                                                                                                                            let super::super::bex::plugin::common::Attr{ key:key59, value:value59, } = e;
                                                                                                                            let vec60 = (key59.into_bytes()).into_boxed_slice();
                                                                                                                            let ptr60 = vec60.as_ptr().cast::<u8>();
                                                                                                                            let len60 = vec60.len();
                                                                                                                            ::core::mem::forget(vec60);
                                                                                                                            *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len60;
                                                                                                                            *base.add(0).cast::<*mut u8>() = ptr60.cast_mut();
                                                                                                                            let vec61 = (value59.into_bytes()).into_boxed_slice();
                                                                                                                            let ptr61 = vec61.as_ptr().cast::<u8>();
                                                                                                                            let len61 = vec61.len();
                                                                                                                            ::core::mem::forget(vec61);
                                                                                                                            *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len61;
                                                                                                                            *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr61.cast_mut();
                                                                                                                          }
                                                                                                                        }
                                                                                                                        *base.add(32+19*::core::mem::size_of::<*const u8>()).cast::<usize>() = len62;
                                                                                                                        *base.add(32+18*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result62;
                                                                                                                      }
                                                                                                                    }
                                                                                                                    *ptr50.add(2*::core::mem::size_of::<*const u8>()).cast::<usize>() = len63;
                                                                                                                    *ptr50.add(::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result63;
                                                                                                                  } },
                                                                                                                  Err(e) => { {
                                                                                                                    *ptr50.add(0).cast::<u8>() = (1i32) as u8;
                                                                                                                    use super::super::bex::plugin::common::PluginError as V68;
                                                                                                                    match e {
                                                                                                                      V68::Network(e) => {
                                                                                                                        *ptr50.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                        let vec64 = (e.into_bytes()).into_boxed_slice();
                                                                                                                        let ptr64 = vec64.as_ptr().cast::<u8>();
                                                                                                                        let len64 = vec64.len();
                                                                                                                        ::core::mem::forget(vec64);
                                                                                                                        *ptr50.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len64;
                                                                                                                        *ptr50.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr64.cast_mut();
                                                                                                                      },
                                                                                                                      V68::Parse(e) => {
                                                                                                                        *ptr50.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                        let vec65 = (e.into_bytes()).into_boxed_slice();
                                                                                                                        let ptr65 = vec65.as_ptr().cast::<u8>();
                                                                                                                        let len65 = vec65.len();
                                                                                                                        ::core::mem::forget(vec65);
                                                                                                                        *ptr50.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len65;
                                                                                                                        *ptr50.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr65.cast_mut();
                                                                                                                      },
                                                                                                                      V68::NotFound=> {
                                                                                                                        {
                                                                                                                          *ptr50.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (2i32) as u8;
                                                                                                                        }
                                                                                                                      }
                                                                                                                      V68::Unauthorized=> {
                                                                                                                        {
                                                                                                                          *ptr50.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (3i32) as u8;
                                                                                                                        }
                                                                                                                      }
                                                                                                                      V68::Forbidden=> {
                                                                                                                        {
                                                                                                                          *ptr50.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (4i32) as u8;
                                                                                                                        }
                                                                                                                      }
                                                                                                                      V68::RateLimited(e) => {
                                                                                                                        *ptr50.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (5i32) as u8;
                                                                                                                        match e {
                                                                                                                          Some(e) => {
                                                                                                                            *ptr50.add(2*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                            *ptr50.add(4+2*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                                          },
                                                                                                                          None => {
                                                                                                                            {
                                                                                                                              *ptr50.add(2*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                            }
                                                                                                                          },
                                                                                                                        };},
                                                                                                                        V68::Timeout=> {
                                                                                                                          {
                                                                                                                            *ptr50.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (6i32) as u8;
                                                                                                                          }
                                                                                                                        }
                                                                                                                        V68::Cancelled=> {
                                                                                                                          {
                                                                                                                            *ptr50.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (7i32) as u8;
                                                                                                                          }
                                                                                                                        }
                                                                                                                        V68::Unsupported=> {
                                                                                                                          {
                                                                                                                            *ptr50.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (8i32) as u8;
                                                                                                                          }
                                                                                                                        }
                                                                                                                        V68::InvalidInput(e) => {
                                                                                                                          *ptr50.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (9i32) as u8;
                                                                                                                          let vec66 = (e.into_bytes()).into_boxed_slice();
                                                                                                                          let ptr66 = vec66.as_ptr().cast::<u8>();
                                                                                                                          let len66 = vec66.len();
                                                                                                                          ::core::mem::forget(vec66);
                                                                                                                          *ptr50.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len66;
                                                                                                                          *ptr50.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr66.cast_mut();
                                                                                                                        },
                                                                                                                        V68::Internal(e) => {
                                                                                                                          *ptr50.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (10i32) as u8;
                                                                                                                          let vec67 = (e.into_bytes()).into_boxed_slice();
                                                                                                                          let ptr67 = vec67.as_ptr().cast::<u8>();
                                                                                                                          let len67 = vec67.len();
                                                                                                                          ::core::mem::forget(vec67);
                                                                                                                          *ptr50.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len67;
                                                                                                                          *ptr50.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr67.cast_mut();
                                                                                                                        },
                                                                                                                      }
                                                                                                                    } },
                                                                                                                  };ptr50
                                                                                                                } }
                                                                                                                #[doc(hidden)]
                                                                                                                #[allow(non_snake_case)]
                                                                                                                pub unsafe fn __post_return_search_subtitles<T_: Guest>(arg0: *mut u8,) { unsafe {
                                                                                                                  let l0 = i32::from(*arg0.add(0).cast::<u8>());
                                                                                                                  match l0 {
                                                                                                                    0 => {
                                                                                                                      let l1 = *arg0.add(::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                      let l2 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      let base27 = l1;
                                                                                                                      let len27 = l2;
                                                                                                                      for i in 0..len27 {
                                                                                                                        let base = base27.add(i * (32+20*::core::mem::size_of::<*const u8>()));
                                                                                                                        {
                                                                                                                          let l3 = *base.add(0).cast::<*mut u8>();
                                                                                                                          let l4 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          _rt::cabi_dealloc(l3, l4, 1);
                                                                                                                          let l5 = *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                          let l6 = *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          _rt::cabi_dealloc(l5, l6, 1);
                                                                                                                          let l7 = *base.add(4*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                          let l8 = *base.add(5*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          _rt::cabi_dealloc(l7, l8, 1);
                                                                                                                          let l9 = *base.add(6*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                          let l10 = *base.add(7*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          _rt::cabi_dealloc(l9, l10, 1);
                                                                                                                          let l11 = i32::from(*base.add(8*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                          match l11 {
                                                                                                                            0 => (),
                                                                                                                            _ => {
                                                                                                                              let l12 = *base.add(9*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                              let l13 = *base.add(10*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                              _rt::cabi_dealloc(l12, l13, 1);
                                                                                                                            },
                                                                                                                          }
                                                                                                                          let l14 = i32::from(*base.add(11*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                          match l14 {
                                                                                                                            0 => (),
                                                                                                                            _ => {
                                                                                                                              let l15 = *base.add(12*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                              let l16 = *base.add(13*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                              _rt::cabi_dealloc(l15, l16, 1);
                                                                                                                            },
                                                                                                                          }
                                                                                                                          let l17 = i32::from(*base.add(32+15*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                          match l17 {
                                                                                                                            0 => (),
                                                                                                                            _ => {
                                                                                                                              let l18 = *base.add(32+16*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                              let l19 = *base.add(32+17*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                              _rt::cabi_dealloc(l18, l19, 1);
                                                                                                                            },
                                                                                                                          }
                                                                                                                          let l20 = *base.add(32+18*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                          let l21 = *base.add(32+19*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          let base26 = l20;
                                                                                                                          let len26 = l21;
                                                                                                                          for i in 0..len26 {
                                                                                                                            let base = base26.add(i * (4*::core::mem::size_of::<*const u8>()));
                                                                                                                            {
                                                                                                                              let l22 = *base.add(0).cast::<*mut u8>();
                                                                                                                              let l23 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                              _rt::cabi_dealloc(l22, l23, 1);
                                                                                                                              let l24 = *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                              let l25 = *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                              _rt::cabi_dealloc(l24, l25, 1);
                                                                                                                            }
                                                                                                                          }
                                                                                                                          _rt::cabi_dealloc(base26, len26 * (4*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                                                                                                        }
                                                                                                                      }
                                                                                                                      _rt::cabi_dealloc(base27, len27 * (32+20*::core::mem::size_of::<*const u8>()), 8);
                                                                                                                    },
                                                                                                                    _ => {
                                                                                                                      let l28 = i32::from(*arg0.add(::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                      match l28 {
                                                                                                                        0 => {
                                                                                                                          let l29 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                          let l30 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          _rt::cabi_dealloc(l29, l30, 1);
                                                                                                                        },
                                                                                                                        1 => {
                                                                                                                          let l31 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                          let l32 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          _rt::cabi_dealloc(l31, l32, 1);
                                                                                                                        },
                                                                                                                        2 => (),
                                                                                                                        3 => (),
                                                                                                                        4 => (),
                                                                                                                        5 => (),
                                                                                                                        6 => (),
                                                                                                                        7 => (),
                                                                                                                        8 => (),
                                                                                                                        9 => {
                                                                                                                          let l33 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                          let l34 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          _rt::cabi_dealloc(l33, l34, 1);
                                                                                                                        },
                                                                                                                        _ => {
                                                                                                                          let l35 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                          let l36 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          _rt::cabi_dealloc(l35, l36, 1);
                                                                                                                        },
                                                                                                                      }
                                                                                                                    },
                                                                                                                  }
                                                                                                                } }
                                                                                                                #[doc(hidden)]
                                                                                                                #[allow(non_snake_case, unused_unsafe)]
                                                                                                                pub unsafe fn _export_download_subtitle_cabi<T_: Guest>(arg0: *mut u8,arg1: usize,arg2: i32,arg3: *mut u8,arg4: usize,arg5: i32,arg6: *mut u8,arg7: usize,arg8: i32,arg9: *mut u8,arg10: usize,arg11: *mut u8,arg12: usize,) -> *mut u8 { unsafe {#[cfg(target_arch="wasm32")]
                                                                                                                _rt::run_ctors_once();let result8 = {
                                                                                                                  let len0 = arg1;
                                                                                                                  let bytes0 = _rt::Vec::from_raw_parts(arg0.cast(), len0, len0);
                                                                                                                  let base6 = arg9;
                                                                                                                  let len6 = arg10;
                                                                                                                  let mut result6 = _rt::Vec::with_capacity(len6);
                                                                                                                  for i in 0..len6 {
                                                                                                                    let base = base6.add(i * (2*::core::mem::size_of::<*const u8>()));
                                                                                                                    let e6 = {
                                                                                                                      let l3 = *base.add(0).cast::<*mut u8>();
                                                                                                                      let l4 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      let len5 = l4;
                                                                                                                      let bytes5 = _rt::Vec::from_raw_parts(l3.cast(), len5, len5);

                                                                                                                      _rt::string_lift(bytes5)
                                                                                                                    };
                                                                                                                    result6.push(e6);
                                                                                                                  }
                                                                                                                  _rt::cabi_dealloc(base6, len6 * (2*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                                                                                                  let len7 = arg12;
                                                                                                                  let bytes7 = _rt::Vec::from_raw_parts(arg11.cast(), len7, len7);
                                                                                                                  T_::download_subtitle(super::super::bex::plugin::common::RequestContext{
                                                                                                                    request_id: _rt::string_lift(bytes0),
                                                                                                                    locale: match arg2 {
                                                                                                                      0 => None,
                                                                                                                      1 => {
                                                                                                                        let e = {
                                                                                                                          let len1 = arg4;
                                                                                                                          let bytes1 = _rt::Vec::from_raw_parts(arg3.cast(), len1, len1);

                                                                                                                          _rt::string_lift(bytes1)
                                                                                                                        };
                                                                                                                        Some(e)
                                                                                                                      }
                                                                                                                      _ => _rt::invalid_enum_discriminant(),
                                                                                                                    },
                                                                                                                    region: match arg5 {
                                                                                                                      0 => None,
                                                                                                                      1 => {
                                                                                                                        let e = {
                                                                                                                          let len2 = arg7;
                                                                                                                          let bytes2 = _rt::Vec::from_raw_parts(arg6.cast(), len2, len2);

                                                                                                                          _rt::string_lift(bytes2)
                                                                                                                        };
                                                                                                                        Some(e)
                                                                                                                      }
                                                                                                                      _ => _rt::invalid_enum_discriminant(),
                                                                                                                    },
                                                                                                                    safe_mode: _rt::bool_lift(arg8 as u8),
                                                                                                                    hints: result6,
                                                                                                                  }, _rt::string_lift(bytes7))
                                                                                                                };
                                                                                                                let ptr9 = (&raw mut _RET_AREA.0).cast::<u8>();
                                                                                                                match result8 {
                                                                                                                  Ok(e) => { {
                                                                                                                    *ptr9.add(0).cast::<u8>() = (0i32) as u8;
                                                                                                                    let super::super::bex::plugin::common::SubtitleFile{ format:format10, content:content10, } = e;
                                                                                                                    let vec11 = (format10.into_bytes()).into_boxed_slice();
                                                                                                                    let ptr11 = vec11.as_ptr().cast::<u8>();
                                                                                                                    let len11 = vec11.len();
                                                                                                                    ::core::mem::forget(vec11);
                                                                                                                    *ptr9.add(2*::core::mem::size_of::<*const u8>()).cast::<usize>() = len11;
                                                                                                                    *ptr9.add(::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr11.cast_mut();
                                                                                                                    let vec12 = <_ as Into<_rt::Vec<_>>>::into(content10).into_boxed_slice();
                                                                                                                    let ptr12 = vec12.as_ptr().cast::<u8>();
                                                                                                                    let len12 = vec12.len();
                                                                                                                    ::core::mem::forget(vec12);
                                                                                                                    *ptr9.add(4*::core::mem::size_of::<*const u8>()).cast::<usize>() = len12;
                                                                                                                    *ptr9.add(3*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr12.cast_mut();
                                                                                                                  } },
                                                                                                                  Err(e) => { {
                                                                                                                    *ptr9.add(0).cast::<u8>() = (1i32) as u8;
                                                                                                                    use super::super::bex::plugin::common::PluginError as V17;
                                                                                                                    match e {
                                                                                                                      V17::Network(e) => {
                                                                                                                        *ptr9.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                        let vec13 = (e.into_bytes()).into_boxed_slice();
                                                                                                                        let ptr13 = vec13.as_ptr().cast::<u8>();
                                                                                                                        let len13 = vec13.len();
                                                                                                                        ::core::mem::forget(vec13);
                                                                                                                        *ptr9.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len13;
                                                                                                                        *ptr9.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr13.cast_mut();
                                                                                                                      },
                                                                                                                      V17::Parse(e) => {
                                                                                                                        *ptr9.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                        let vec14 = (e.into_bytes()).into_boxed_slice();
                                                                                                                        let ptr14 = vec14.as_ptr().cast::<u8>();
                                                                                                                        let len14 = vec14.len();
                                                                                                                        ::core::mem::forget(vec14);
                                                                                                                        *ptr9.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len14;
                                                                                                                        *ptr9.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr14.cast_mut();
                                                                                                                      },
                                                                                                                      V17::NotFound=> {
                                                                                                                        {
                                                                                                                          *ptr9.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (2i32) as u8;
                                                                                                                        }
                                                                                                                      }
                                                                                                                      V17::Unauthorized=> {
                                                                                                                        {
                                                                                                                          *ptr9.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (3i32) as u8;
                                                                                                                        }
                                                                                                                      }
                                                                                                                      V17::Forbidden=> {
                                                                                                                        {
                                                                                                                          *ptr9.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (4i32) as u8;
                                                                                                                        }
                                                                                                                      }
                                                                                                                      V17::RateLimited(e) => {
                                                                                                                        *ptr9.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (5i32) as u8;
                                                                                                                        match e {
                                                                                                                          Some(e) => {
                                                                                                                            *ptr9.add(2*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                            *ptr9.add(4+2*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                                          },
                                                                                                                          None => {
                                                                                                                            {
                                                                                                                              *ptr9.add(2*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                            }
                                                                                                                          },
                                                                                                                        };},
                                                                                                                        V17::Timeout=> {
                                                                                                                          {
                                                                                                                            *ptr9.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (6i32) as u8;
                                                                                                                          }
                                                                                                                        }
                                                                                                                        V17::Cancelled=> {
                                                                                                                          {
                                                                                                                            *ptr9.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (7i32) as u8;
                                                                                                                          }
                                                                                                                        }
                                                                                                                        V17::Unsupported=> {
                                                                                                                          {
                                                                                                                            *ptr9.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (8i32) as u8;
                                                                                                                          }
                                                                                                                        }
                                                                                                                        V17::InvalidInput(e) => {
                                                                                                                          *ptr9.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (9i32) as u8;
                                                                                                                          let vec15 = (e.into_bytes()).into_boxed_slice();
                                                                                                                          let ptr15 = vec15.as_ptr().cast::<u8>();
                                                                                                                          let len15 = vec15.len();
                                                                                                                          ::core::mem::forget(vec15);
                                                                                                                          *ptr9.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len15;
                                                                                                                          *ptr9.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr15.cast_mut();
                                                                                                                        },
                                                                                                                        V17::Internal(e) => {
                                                                                                                          *ptr9.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (10i32) as u8;
                                                                                                                          let vec16 = (e.into_bytes()).into_boxed_slice();
                                                                                                                          let ptr16 = vec16.as_ptr().cast::<u8>();
                                                                                                                          let len16 = vec16.len();
                                                                                                                          ::core::mem::forget(vec16);
                                                                                                                          *ptr9.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len16;
                                                                                                                          *ptr9.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr16.cast_mut();
                                                                                                                        },
                                                                                                                      }
                                                                                                                    } },
                                                                                                                  };ptr9
                                                                                                                } }
                                                                                                                #[doc(hidden)]
                                                                                                                #[allow(non_snake_case)]
                                                                                                                pub unsafe fn __post_return_download_subtitle<T_: Guest>(arg0: *mut u8,) { unsafe {
                                                                                                                  let l0 = i32::from(*arg0.add(0).cast::<u8>());
                                                                                                                  match l0 {
                                                                                                                    0 => {
                                                                                                                      let l1 = *arg0.add(::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                      let l2 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      _rt::cabi_dealloc(l1, l2, 1);
                                                                                                                      let l3 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                      let l4 = *arg0.add(4*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      let base5 = l3;
                                                                                                                      let len5 = l4;
                                                                                                                      _rt::cabi_dealloc(base5, len5 * 1, 1);
                                                                                                                    },
                                                                                                                    _ => {
                                                                                                                      let l6 = i32::from(*arg0.add(::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                      match l6 {
                                                                                                                        0 => {
                                                                                                                          let l7 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                          let l8 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          _rt::cabi_dealloc(l7, l8, 1);
                                                                                                                        },
                                                                                                                        1 => {
                                                                                                                          let l9 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                          let l10 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          _rt::cabi_dealloc(l9, l10, 1);
                                                                                                                        },
                                                                                                                        2 => (),
                                                                                                                        3 => (),
                                                                                                                        4 => (),
                                                                                                                        5 => (),
                                                                                                                        6 => (),
                                                                                                                        7 => (),
                                                                                                                        8 => (),
                                                                                                                        9 => {
                                                                                                                          let l11 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                          let l12 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          _rt::cabi_dealloc(l11, l12, 1);
                                                                                                                        },
                                                                                                                        _ => {
                                                                                                                          let l13 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                          let l14 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                          _rt::cabi_dealloc(l13, l14, 1);
                                                                                                                        },
                                                                                                                      }
                                                                                                                    },
                                                                                                                  }
                                                                                                                } }
                                                                                                                #[doc(hidden)]
                                                                                                                #[allow(non_snake_case, unused_unsafe)]
                                                                                                                pub unsafe fn _export_get_articles_cabi<T_: Guest>(arg0: *mut u8,arg1: usize,arg2: i32,arg3: *mut u8,arg4: usize,arg5: i32,arg6: *mut u8,arg7: usize,arg8: i32,arg9: *mut u8,arg10: usize,) -> *mut u8 { unsafe {#[cfg(target_arch="wasm32")]
                                                                                                                _rt::run_ctors_once();let result7 = {
                                                                                                                  let len0 = arg1;
                                                                                                                  let bytes0 = _rt::Vec::from_raw_parts(arg0.cast(), len0, len0);
                                                                                                                  let base6 = arg9;
                                                                                                                  let len6 = arg10;
                                                                                                                  let mut result6 = _rt::Vec::with_capacity(len6);
                                                                                                                  for i in 0..len6 {
                                                                                                                    let base = base6.add(i * (2*::core::mem::size_of::<*const u8>()));
                                                                                                                    let e6 = {
                                                                                                                      let l3 = *base.add(0).cast::<*mut u8>();
                                                                                                                      let l4 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                      let len5 = l4;
                                                                                                                      let bytes5 = _rt::Vec::from_raw_parts(l3.cast(), len5, len5);

                                                                                                                      _rt::string_lift(bytes5)
                                                                                                                    };
                                                                                                                    result6.push(e6);
                                                                                                                  }
                                                                                                                  _rt::cabi_dealloc(base6, len6 * (2*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                                                                                                  T_::get_articles(super::super::bex::plugin::common::RequestContext{
                                                                                                                    request_id: _rt::string_lift(bytes0),
                                                                                                                    locale: match arg2 {
                                                                                                                      0 => None,
                                                                                                                      1 => {
                                                                                                                        let e = {
                                                                                                                          let len1 = arg4;
                                                                                                                          let bytes1 = _rt::Vec::from_raw_parts(arg3.cast(), len1, len1);

                                                                                                                          _rt::string_lift(bytes1)
                                                                                                                        };
                                                                                                                        Some(e)
                                                                                                                      }
                                                                                                                      _ => _rt::invalid_enum_discriminant(),
                                                                                                                    },
                                                                                                                    region: match arg5 {
                                                                                                                      0 => None,
                                                                                                                      1 => {
                                                                                                                        let e = {
                                                                                                                          let len2 = arg7;
                                                                                                                          let bytes2 = _rt::Vec::from_raw_parts(arg6.cast(), len2, len2);

                                                                                                                          _rt::string_lift(bytes2)
                                                                                                                        };
                                                                                                                        Some(e)
                                                                                                                      }
                                                                                                                      _ => _rt::invalid_enum_discriminant(),
                                                                                                                    },
                                                                                                                    safe_mode: _rt::bool_lift(arg8 as u8),
                                                                                                                    hints: result6,
                                                                                                                  })
                                                                                                                };
                                                                                                                let ptr8 = (&raw mut _RET_AREA.0).cast::<u8>();
                                                                                                                match result7 {
                                                                                                                  Ok(e) => { {
                                                                                                                    *ptr8.add(0).cast::<u8>() = (0i32) as u8;
                                                                                                                    let vec43 = e;
                                                                                                                    let len43 = vec43.len();
                                                                                                                    let layout43 = _rt::alloc::Layout::from_size_align(vec43.len() * (9*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>()).unwrap();
                                                                                                                    let (result43, _cleanup43) = wit_bindgen::rt::Cleanup::new(layout43);if let Some(cleanup) = _cleanup43 { cleanup.forget(); }
                                                                                                                    for (i, e) in vec43.into_iter().enumerate() {
                                                                                                                      let base = result43.add(i * (9*::core::mem::size_of::<*const u8>()));
                                                                                                                      {
                                                                                                                        let super::super::bex::plugin::common::ArticleSection{ id:id9, title:title9, items:items9, next_page:next_page9, } = e;
                                                                                                                        let vec10 = (id9.into_bytes()).into_boxed_slice();
                                                                                                                        let ptr10 = vec10.as_ptr().cast::<u8>();
                                                                                                                        let len10 = vec10.len();
                                                                                                                        ::core::mem::forget(vec10);
                                                                                                                        *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len10;
                                                                                                                        *base.add(0).cast::<*mut u8>() = ptr10.cast_mut();
                                                                                                                        let vec11 = (title9.into_bytes()).into_boxed_slice();
                                                                                                                        let ptr11 = vec11.as_ptr().cast::<u8>();
                                                                                                                        let len11 = vec11.len();
                                                                                                                        ::core::mem::forget(vec11);
                                                                                                                        *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len11;
                                                                                                                        *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr11.cast_mut();
                                                                                                                        let vec41 = items9;
                                                                                                                        let len41 = vec41.len();
                                                                                                                        let layout41 = _rt::alloc::Layout::from_size_align(vec41.len() * (80+55*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>()).unwrap();
                                                                                                                        let (result41, _cleanup41) = wit_bindgen::rt::Cleanup::new(layout41);if let Some(cleanup) = _cleanup41 { cleanup.forget(); }
                                                                                                                        for (i, e) in vec41.into_iter().enumerate() {
                                                                                                                          let base = result41.add(i * (80+55*::core::mem::size_of::<*const u8>()));
                                                                                                                          {
                                                                                                                            let super::super::bex::plugin::common::Article{ id:id12, title:title12, summary:summary12, url:url12, published:published12, author:author12, thumbnail:thumbnail12, tags:tags12, extra:extra12, } = e;
                                                                                                                            let vec13 = (id12.into_bytes()).into_boxed_slice();
                                                                                                                            let ptr13 = vec13.as_ptr().cast::<u8>();
                                                                                                                            let len13 = vec13.len();
                                                                                                                            ::core::mem::forget(vec13);
                                                                                                                            *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len13;
                                                                                                                            *base.add(0).cast::<*mut u8>() = ptr13.cast_mut();
                                                                                                                            let vec14 = (title12.into_bytes()).into_boxed_slice();
                                                                                                                            let ptr14 = vec14.as_ptr().cast::<u8>();
                                                                                                                            let len14 = vec14.len();
                                                                                                                            ::core::mem::forget(vec14);
                                                                                                                            *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len14;
                                                                                                                            *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr14.cast_mut();
                                                                                                                            match summary12 {
                                                                                                                              Some(e) => {
                                                                                                                                *base.add(4*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                let vec15 = (e.into_bytes()).into_boxed_slice();
                                                                                                                                let ptr15 = vec15.as_ptr().cast::<u8>();
                                                                                                                                let len15 = vec15.len();
                                                                                                                                ::core::mem::forget(vec15);
                                                                                                                                *base.add(6*::core::mem::size_of::<*const u8>()).cast::<usize>() = len15;
                                                                                                                                *base.add(5*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr15.cast_mut();
                                                                                                                              },
                                                                                                                              None => {
                                                                                                                                {
                                                                                                                                  *base.add(4*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                }
                                                                                                                              },
                                                                                                                            };let vec16 = (url12.into_bytes()).into_boxed_slice();
                                                                                                                            let ptr16 = vec16.as_ptr().cast::<u8>();
                                                                                                                            let len16 = vec16.len();
                                                                                                                            ::core::mem::forget(vec16);
                                                                                                                            *base.add(8*::core::mem::size_of::<*const u8>()).cast::<usize>() = len16;
                                                                                                                            *base.add(7*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr16.cast_mut();
                                                                                                                            match published12 {
                                                                                                                              Some(e) => {
                                                                                                                                *base.add(9*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                let vec17 = (e.into_bytes()).into_boxed_slice();
                                                                                                                                let ptr17 = vec17.as_ptr().cast::<u8>();
                                                                                                                                let len17 = vec17.len();
                                                                                                                                ::core::mem::forget(vec17);
                                                                                                                                *base.add(11*::core::mem::size_of::<*const u8>()).cast::<usize>() = len17;
                                                                                                                                *base.add(10*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr17.cast_mut();
                                                                                                                              },
                                                                                                                              None => {
                                                                                                                                {
                                                                                                                                  *base.add(9*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                }
                                                                                                                              },
                                                                                                                            };match author12 {
                                                                                                                              Some(e) => {
                                                                                                                                *base.add(12*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                let vec18 = (e.into_bytes()).into_boxed_slice();
                                                                                                                                let ptr18 = vec18.as_ptr().cast::<u8>();
                                                                                                                                let len18 = vec18.len();
                                                                                                                                ::core::mem::forget(vec18);
                                                                                                                                *base.add(14*::core::mem::size_of::<*const u8>()).cast::<usize>() = len18;
                                                                                                                                *base.add(13*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr18.cast_mut();
                                                                                                                              },
                                                                                                                              None => {
                                                                                                                                {
                                                                                                                                  *base.add(12*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                }
                                                                                                                              },
                                                                                                                            };match thumbnail12 {
                                                                                                                              Some(e) => {
                                                                                                                                *base.add(15*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                let super::super::bex::plugin::common::ImageSet{ low:low19, medium:medium19, high:high19, backdrop:backdrop19, logo:logo19, } = e;
                                                                                                                                match low19 {
                                                                                                                                  Some(e) => {
                                                                                                                                    *base.add(16*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                    let super::super::bex::plugin::common::Image{ url:url20, layout:layout20, width:width20, height:height20, blurhash:blurhash20, } = e;
                                                                                                                                    let vec21 = (url20.into_bytes()).into_boxed_slice();
                                                                                                                                    let ptr21 = vec21.as_ptr().cast::<u8>();
                                                                                                                                    let len21 = vec21.len();
                                                                                                                                    ::core::mem::forget(vec21);
                                                                                                                                    *base.add(18*::core::mem::size_of::<*const u8>()).cast::<usize>() = len21;
                                                                                                                                    *base.add(17*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr21.cast_mut();
                                                                                                                                    *base.add(19*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout20.clone() as i32) as u8;
                                                                                                                                    match width20 {
                                                                                                                                      Some(e) => {
                                                                                                                                        *base.add(4+19*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                        *base.add(8+19*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                                                      },
                                                                                                                                      None => {
                                                                                                                                        {
                                                                                                                                          *base.add(4+19*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                        }
                                                                                                                                      },
                                                                                                                                    };match height20 {
                                                                                                                                      Some(e) => {
                                                                                                                                        *base.add(12+19*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                        *base.add(16+19*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                                                      },
                                                                                                                                      None => {
                                                                                                                                        {
                                                                                                                                          *base.add(12+19*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                        }
                                                                                                                                      },
                                                                                                                                    };match blurhash20 {
                                                                                                                                      Some(e) => {
                                                                                                                                        *base.add(16+20*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                        let vec22 = (e.into_bytes()).into_boxed_slice();
                                                                                                                                        let ptr22 = vec22.as_ptr().cast::<u8>();
                                                                                                                                        let len22 = vec22.len();
                                                                                                                                        ::core::mem::forget(vec22);
                                                                                                                                        *base.add(16+22*::core::mem::size_of::<*const u8>()).cast::<usize>() = len22;
                                                                                                                                        *base.add(16+21*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr22.cast_mut();
                                                                                                                                      },
                                                                                                                                      None => {
                                                                                                                                        {
                                                                                                                                          *base.add(16+20*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                        }
                                                                                                                                      },
                                                                                                                                    };},
                                                                                                                                    None => {
                                                                                                                                      {
                                                                                                                                        *base.add(16*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                      }
                                                                                                                                    },
                                                                                                                                  };match medium19 {
                                                                                                                                    Some(e) => {
                                                                                                                                      *base.add(16+23*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                      let super::super::bex::plugin::common::Image{ url:url23, layout:layout23, width:width23, height:height23, blurhash:blurhash23, } = e;
                                                                                                                                      let vec24 = (url23.into_bytes()).into_boxed_slice();
                                                                                                                                      let ptr24 = vec24.as_ptr().cast::<u8>();
                                                                                                                                      let len24 = vec24.len();
                                                                                                                                      ::core::mem::forget(vec24);
                                                                                                                                      *base.add(16+25*::core::mem::size_of::<*const u8>()).cast::<usize>() = len24;
                                                                                                                                      *base.add(16+24*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr24.cast_mut();
                                                                                                                                      *base.add(16+26*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout23.clone() as i32) as u8;
                                                                                                                                      match width23 {
                                                                                                                                        Some(e) => {
                                                                                                                                          *base.add(20+26*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                          *base.add(24+26*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                                                        },
                                                                                                                                        None => {
                                                                                                                                          {
                                                                                                                                            *base.add(20+26*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                          }
                                                                                                                                        },
                                                                                                                                      };match height23 {
                                                                                                                                        Some(e) => {
                                                                                                                                          *base.add(28+26*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                          *base.add(32+26*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                                                        },
                                                                                                                                        None => {
                                                                                                                                          {
                                                                                                                                            *base.add(28+26*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                          }
                                                                                                                                        },
                                                                                                                                      };match blurhash23 {
                                                                                                                                        Some(e) => {
                                                                                                                                          *base.add(32+27*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                          let vec25 = (e.into_bytes()).into_boxed_slice();
                                                                                                                                          let ptr25 = vec25.as_ptr().cast::<u8>();
                                                                                                                                          let len25 = vec25.len();
                                                                                                                                          ::core::mem::forget(vec25);
                                                                                                                                          *base.add(32+29*::core::mem::size_of::<*const u8>()).cast::<usize>() = len25;
                                                                                                                                          *base.add(32+28*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr25.cast_mut();
                                                                                                                                        },
                                                                                                                                        None => {
                                                                                                                                          {
                                                                                                                                            *base.add(32+27*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                          }
                                                                                                                                        },
                                                                                                                                      };},
                                                                                                                                      None => {
                                                                                                                                        {
                                                                                                                                          *base.add(16+23*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                        }
                                                                                                                                      },
                                                                                                                                    };match high19 {
                                                                                                                                      Some(e) => {
                                                                                                                                        *base.add(32+30*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                        let super::super::bex::plugin::common::Image{ url:url26, layout:layout26, width:width26, height:height26, blurhash:blurhash26, } = e;
                                                                                                                                        let vec27 = (url26.into_bytes()).into_boxed_slice();
                                                                                                                                        let ptr27 = vec27.as_ptr().cast::<u8>();
                                                                                                                                        let len27 = vec27.len();
                                                                                                                                        ::core::mem::forget(vec27);
                                                                                                                                        *base.add(32+32*::core::mem::size_of::<*const u8>()).cast::<usize>() = len27;
                                                                                                                                        *base.add(32+31*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr27.cast_mut();
                                                                                                                                        *base.add(32+33*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout26.clone() as i32) as u8;
                                                                                                                                        match width26 {
                                                                                                                                          Some(e) => {
                                                                                                                                            *base.add(36+33*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                            *base.add(40+33*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                                                          },
                                                                                                                                          None => {
                                                                                                                                            {
                                                                                                                                              *base.add(36+33*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                            }
                                                                                                                                          },
                                                                                                                                        };match height26 {
                                                                                                                                          Some(e) => {
                                                                                                                                            *base.add(44+33*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                            *base.add(48+33*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                                                          },
                                                                                                                                          None => {
                                                                                                                                            {
                                                                                                                                              *base.add(44+33*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                            }
                                                                                                                                          },
                                                                                                                                        };match blurhash26 {
                                                                                                                                          Some(e) => {
                                                                                                                                            *base.add(48+34*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                            let vec28 = (e.into_bytes()).into_boxed_slice();
                                                                                                                                            let ptr28 = vec28.as_ptr().cast::<u8>();
                                                                                                                                            let len28 = vec28.len();
                                                                                                                                            ::core::mem::forget(vec28);
                                                                                                                                            *base.add(48+36*::core::mem::size_of::<*const u8>()).cast::<usize>() = len28;
                                                                                                                                            *base.add(48+35*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr28.cast_mut();
                                                                                                                                          },
                                                                                                                                          None => {
                                                                                                                                            {
                                                                                                                                              *base.add(48+34*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                            }
                                                                                                                                          },
                                                                                                                                        };},
                                                                                                                                        None => {
                                                                                                                                          {
                                                                                                                                            *base.add(32+30*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                          }
                                                                                                                                        },
                                                                                                                                      };match backdrop19 {
                                                                                                                                        Some(e) => {
                                                                                                                                          *base.add(48+37*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                          let super::super::bex::plugin::common::Image{ url:url29, layout:layout29, width:width29, height:height29, blurhash:blurhash29, } = e;
                                                                                                                                          let vec30 = (url29.into_bytes()).into_boxed_slice();
                                                                                                                                          let ptr30 = vec30.as_ptr().cast::<u8>();
                                                                                                                                          let len30 = vec30.len();
                                                                                                                                          ::core::mem::forget(vec30);
                                                                                                                                          *base.add(48+39*::core::mem::size_of::<*const u8>()).cast::<usize>() = len30;
                                                                                                                                          *base.add(48+38*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr30.cast_mut();
                                                                                                                                          *base.add(48+40*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout29.clone() as i32) as u8;
                                                                                                                                          match width29 {
                                                                                                                                            Some(e) => {
                                                                                                                                              *base.add(52+40*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                              *base.add(56+40*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                                                            },
                                                                                                                                            None => {
                                                                                                                                              {
                                                                                                                                                *base.add(52+40*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                              }
                                                                                                                                            },
                                                                                                                                          };match height29 {
                                                                                                                                            Some(e) => {
                                                                                                                                              *base.add(60+40*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                              *base.add(64+40*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                                                            },
                                                                                                                                            None => {
                                                                                                                                              {
                                                                                                                                                *base.add(60+40*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                              }
                                                                                                                                            },
                                                                                                                                          };match blurhash29 {
                                                                                                                                            Some(e) => {
                                                                                                                                              *base.add(64+41*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                              let vec31 = (e.into_bytes()).into_boxed_slice();
                                                                                                                                              let ptr31 = vec31.as_ptr().cast::<u8>();
                                                                                                                                              let len31 = vec31.len();
                                                                                                                                              ::core::mem::forget(vec31);
                                                                                                                                              *base.add(64+43*::core::mem::size_of::<*const u8>()).cast::<usize>() = len31;
                                                                                                                                              *base.add(64+42*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr31.cast_mut();
                                                                                                                                            },
                                                                                                                                            None => {
                                                                                                                                              {
                                                                                                                                                *base.add(64+41*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                              }
                                                                                                                                            },
                                                                                                                                          };},
                                                                                                                                          None => {
                                                                                                                                            {
                                                                                                                                              *base.add(48+37*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                            }
                                                                                                                                          },
                                                                                                                                        };match logo19 {
                                                                                                                                          Some(e) => {
                                                                                                                                            *base.add(64+44*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                            let super::super::bex::plugin::common::Image{ url:url32, layout:layout32, width:width32, height:height32, blurhash:blurhash32, } = e;
                                                                                                                                            let vec33 = (url32.into_bytes()).into_boxed_slice();
                                                                                                                                            let ptr33 = vec33.as_ptr().cast::<u8>();
                                                                                                                                            let len33 = vec33.len();
                                                                                                                                            ::core::mem::forget(vec33);
                                                                                                                                            *base.add(64+46*::core::mem::size_of::<*const u8>()).cast::<usize>() = len33;
                                                                                                                                            *base.add(64+45*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr33.cast_mut();
                                                                                                                                            *base.add(64+47*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout32.clone() as i32) as u8;
                                                                                                                                            match width32 {
                                                                                                                                              Some(e) => {
                                                                                                                                                *base.add(68+47*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                                *base.add(72+47*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                                                              },
                                                                                                                                              None => {
                                                                                                                                                {
                                                                                                                                                  *base.add(68+47*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                                }
                                                                                                                                              },
                                                                                                                                            };match height32 {
                                                                                                                                              Some(e) => {
                                                                                                                                                *base.add(76+47*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                                *base.add(80+47*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                                                              },
                                                                                                                                              None => {
                                                                                                                                                {
                                                                                                                                                  *base.add(76+47*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                                }
                                                                                                                                              },
                                                                                                                                            };match blurhash32 {
                                                                                                                                              Some(e) => {
                                                                                                                                                *base.add(80+48*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                                let vec34 = (e.into_bytes()).into_boxed_slice();
                                                                                                                                                let ptr34 = vec34.as_ptr().cast::<u8>();
                                                                                                                                                let len34 = vec34.len();
                                                                                                                                                ::core::mem::forget(vec34);
                                                                                                                                                *base.add(80+50*::core::mem::size_of::<*const u8>()).cast::<usize>() = len34;
                                                                                                                                                *base.add(80+49*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr34.cast_mut();
                                                                                                                                              },
                                                                                                                                              None => {
                                                                                                                                                {
                                                                                                                                                  *base.add(80+48*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                                }
                                                                                                                                              },
                                                                                                                                            };},
                                                                                                                                            None => {
                                                                                                                                              {
                                                                                                                                                *base.add(64+44*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                              }
                                                                                                                                            },
                                                                                                                                          };},
                                                                                                                                          None => {
                                                                                                                                            {
                                                                                                                                              *base.add(15*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                            }
                                                                                                                                          },
                                                                                                                                        };let vec36 = tags12;
                                                                                                                                        let len36 = vec36.len();
                                                                                                                                        let layout36 = _rt::alloc::Layout::from_size_align(vec36.len() * (2*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>()).unwrap();
                                                                                                                                        let (result36, _cleanup36) = wit_bindgen::rt::Cleanup::new(layout36);if let Some(cleanup) = _cleanup36 { cleanup.forget(); }
                                                                                                                                        for (i, e) in vec36.into_iter().enumerate() {
                                                                                                                                          let base = result36.add(i * (2*::core::mem::size_of::<*const u8>()));
                                                                                                                                          {
                                                                                                                                            let vec35 = (e.into_bytes()).into_boxed_slice();
                                                                                                                                            let ptr35 = vec35.as_ptr().cast::<u8>();
                                                                                                                                            let len35 = vec35.len();
                                                                                                                                            ::core::mem::forget(vec35);
                                                                                                                                            *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len35;
                                                                                                                                            *base.add(0).cast::<*mut u8>() = ptr35.cast_mut();
                                                                                                                                          }
                                                                                                                                        }
                                                                                                                                        *base.add(80+52*::core::mem::size_of::<*const u8>()).cast::<usize>() = len36;
                                                                                                                                        *base.add(80+51*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result36;
                                                                                                                                        let vec40 = extra12;
                                                                                                                                        let len40 = vec40.len();
                                                                                                                                        let layout40 = _rt::alloc::Layout::from_size_align(vec40.len() * (4*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>()).unwrap();
                                                                                                                                        let (result40, _cleanup40) = wit_bindgen::rt::Cleanup::new(layout40);if let Some(cleanup) = _cleanup40 { cleanup.forget(); }
                                                                                                                                        for (i, e) in vec40.into_iter().enumerate() {
                                                                                                                                          let base = result40.add(i * (4*::core::mem::size_of::<*const u8>()));
                                                                                                                                          {
                                                                                                                                            let super::super::bex::plugin::common::Attr{ key:key37, value:value37, } = e;
                                                                                                                                            let vec38 = (key37.into_bytes()).into_boxed_slice();
                                                                                                                                            let ptr38 = vec38.as_ptr().cast::<u8>();
                                                                                                                                            let len38 = vec38.len();
                                                                                                                                            ::core::mem::forget(vec38);
                                                                                                                                            *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len38;
                                                                                                                                            *base.add(0).cast::<*mut u8>() = ptr38.cast_mut();
                                                                                                                                            let vec39 = (value37.into_bytes()).into_boxed_slice();
                                                                                                                                            let ptr39 = vec39.as_ptr().cast::<u8>();
                                                                                                                                            let len39 = vec39.len();
                                                                                                                                            ::core::mem::forget(vec39);
                                                                                                                                            *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len39;
                                                                                                                                            *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr39.cast_mut();
                                                                                                                                          }
                                                                                                                                        }
                                                                                                                                        *base.add(80+54*::core::mem::size_of::<*const u8>()).cast::<usize>() = len40;
                                                                                                                                        *base.add(80+53*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result40;
                                                                                                                                      }
                                                                                                                                    }
                                                                                                                                    *base.add(5*::core::mem::size_of::<*const u8>()).cast::<usize>() = len41;
                                                                                                                                    *base.add(4*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result41;
                                                                                                                                    match next_page9 {
                                                                                                                                      Some(e) => {
                                                                                                                                        *base.add(6*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                        let vec42 = (e.into_bytes()).into_boxed_slice();
                                                                                                                                        let ptr42 = vec42.as_ptr().cast::<u8>();
                                                                                                                                        let len42 = vec42.len();
                                                                                                                                        ::core::mem::forget(vec42);
                                                                                                                                        *base.add(8*::core::mem::size_of::<*const u8>()).cast::<usize>() = len42;
                                                                                                                                        *base.add(7*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr42.cast_mut();
                                                                                                                                      },
                                                                                                                                      None => {
                                                                                                                                        {
                                                                                                                                          *base.add(6*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                        }
                                                                                                                                      },
                                                                                                                                    };}
                                                                                                                                  }
                                                                                                                                  *ptr8.add(2*::core::mem::size_of::<*const u8>()).cast::<usize>() = len43;
                                                                                                                                  *ptr8.add(::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result43;
                                                                                                                                } },
                                                                                                                                Err(e) => { {
                                                                                                                                  *ptr8.add(0).cast::<u8>() = (1i32) as u8;
                                                                                                                                  use super::super::bex::plugin::common::PluginError as V48;
                                                                                                                                  match e {
                                                                                                                                    V48::Network(e) => {
                                                                                                                                      *ptr8.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                      let vec44 = (e.into_bytes()).into_boxed_slice();
                                                                                                                                      let ptr44 = vec44.as_ptr().cast::<u8>();
                                                                                                                                      let len44 = vec44.len();
                                                                                                                                      ::core::mem::forget(vec44);
                                                                                                                                      *ptr8.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len44;
                                                                                                                                      *ptr8.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr44.cast_mut();
                                                                                                                                    },
                                                                                                                                    V48::Parse(e) => {
                                                                                                                                      *ptr8.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                      let vec45 = (e.into_bytes()).into_boxed_slice();
                                                                                                                                      let ptr45 = vec45.as_ptr().cast::<u8>();
                                                                                                                                      let len45 = vec45.len();
                                                                                                                                      ::core::mem::forget(vec45);
                                                                                                                                      *ptr8.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len45;
                                                                                                                                      *ptr8.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr45.cast_mut();
                                                                                                                                    },
                                                                                                                                    V48::NotFound=> {
                                                                                                                                      {
                                                                                                                                        *ptr8.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (2i32) as u8;
                                                                                                                                      }
                                                                                                                                    }
                                                                                                                                    V48::Unauthorized=> {
                                                                                                                                      {
                                                                                                                                        *ptr8.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (3i32) as u8;
                                                                                                                                      }
                                                                                                                                    }
                                                                                                                                    V48::Forbidden=> {
                                                                                                                                      {
                                                                                                                                        *ptr8.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (4i32) as u8;
                                                                                                                                      }
                                                                                                                                    }
                                                                                                                                    V48::RateLimited(e) => {
                                                                                                                                      *ptr8.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (5i32) as u8;
                                                                                                                                      match e {
                                                                                                                                        Some(e) => {
                                                                                                                                          *ptr8.add(2*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                          *ptr8.add(4+2*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                                                        },
                                                                                                                                        None => {
                                                                                                                                          {
                                                                                                                                            *ptr8.add(2*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                          }
                                                                                                                                        },
                                                                                                                                      };},
                                                                                                                                      V48::Timeout=> {
                                                                                                                                        {
                                                                                                                                          *ptr8.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (6i32) as u8;
                                                                                                                                        }
                                                                                                                                      }
                                                                                                                                      V48::Cancelled=> {
                                                                                                                                        {
                                                                                                                                          *ptr8.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (7i32) as u8;
                                                                                                                                        }
                                                                                                                                      }
                                                                                                                                      V48::Unsupported=> {
                                                                                                                                        {
                                                                                                                                          *ptr8.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (8i32) as u8;
                                                                                                                                        }
                                                                                                                                      }
                                                                                                                                      V48::InvalidInput(e) => {
                                                                                                                                        *ptr8.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (9i32) as u8;
                                                                                                                                        let vec46 = (e.into_bytes()).into_boxed_slice();
                                                                                                                                        let ptr46 = vec46.as_ptr().cast::<u8>();
                                                                                                                                        let len46 = vec46.len();
                                                                                                                                        ::core::mem::forget(vec46);
                                                                                                                                        *ptr8.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len46;
                                                                                                                                        *ptr8.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr46.cast_mut();
                                                                                                                                      },
                                                                                                                                      V48::Internal(e) => {
                                                                                                                                        *ptr8.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (10i32) as u8;
                                                                                                                                        let vec47 = (e.into_bytes()).into_boxed_slice();
                                                                                                                                        let ptr47 = vec47.as_ptr().cast::<u8>();
                                                                                                                                        let len47 = vec47.len();
                                                                                                                                        ::core::mem::forget(vec47);
                                                                                                                                        *ptr8.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len47;
                                                                                                                                        *ptr8.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr47.cast_mut();
                                                                                                                                      },
                                                                                                                                    }
                                                                                                                                  } },
                                                                                                                                };ptr8
                                                                                                                              } }
                                                                                                                              #[doc(hidden)]
                                                                                                                              #[allow(non_snake_case)]
                                                                                                                              pub unsafe fn __post_return_get_articles<T_: Guest>(arg0: *mut u8,) { unsafe {
                                                                                                                                let l0 = i32::from(*arg0.add(0).cast::<u8>());
                                                                                                                                match l0 {
                                                                                                                                  0 => {
                                                                                                                                    let l1 = *arg0.add(::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                    let l2 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                    let base71 = l1;
                                                                                                                                    let len71 = l2;
                                                                                                                                    for i in 0..len71 {
                                                                                                                                      let base = base71.add(i * (9*::core::mem::size_of::<*const u8>()));
                                                                                                                                      {
                                                                                                                                        let l3 = *base.add(0).cast::<*mut u8>();
                                                                                                                                        let l4 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                        _rt::cabi_dealloc(l3, l4, 1);
                                                                                                                                        let l5 = *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                        let l6 = *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                        _rt::cabi_dealloc(l5, l6, 1);
                                                                                                                                        let l7 = *base.add(4*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                        let l8 = *base.add(5*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                        let base67 = l7;
                                                                                                                                        let len67 = l8;
                                                                                                                                        for i in 0..len67 {
                                                                                                                                          let base = base67.add(i * (80+55*::core::mem::size_of::<*const u8>()));
                                                                                                                                          {
                                                                                                                                            let l9 = *base.add(0).cast::<*mut u8>();
                                                                                                                                            let l10 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                            _rt::cabi_dealloc(l9, l10, 1);
                                                                                                                                            let l11 = *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                            let l12 = *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                            _rt::cabi_dealloc(l11, l12, 1);
                                                                                                                                            let l13 = i32::from(*base.add(4*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                                            match l13 {
                                                                                                                                              0 => (),
                                                                                                                                              _ => {
                                                                                                                                                let l14 = *base.add(5*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                                let l15 = *base.add(6*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                _rt::cabi_dealloc(l14, l15, 1);
                                                                                                                                              },
                                                                                                                                            }
                                                                                                                                            let l16 = *base.add(7*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                            let l17 = *base.add(8*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                            _rt::cabi_dealloc(l16, l17, 1);
                                                                                                                                            let l18 = i32::from(*base.add(9*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                                            match l18 {
                                                                                                                                              0 => (),
                                                                                                                                              _ => {
                                                                                                                                                let l19 = *base.add(10*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                                let l20 = *base.add(11*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                _rt::cabi_dealloc(l19, l20, 1);
                                                                                                                                              },
                                                                                                                                            }
                                                                                                                                            let l21 = i32::from(*base.add(12*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                                            match l21 {
                                                                                                                                              0 => (),
                                                                                                                                              _ => {
                                                                                                                                                let l22 = *base.add(13*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                                let l23 = *base.add(14*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                _rt::cabi_dealloc(l22, l23, 1);
                                                                                                                                              },
                                                                                                                                            }
                                                                                                                                            let l24 = i32::from(*base.add(15*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                                            match l24 {
                                                                                                                                              0 => (),
                                                                                                                                              _ => {
                                                                                                                                                let l25 = i32::from(*base.add(16*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                                                match l25 {
                                                                                                                                                  0 => (),
                                                                                                                                                  _ => {
                                                                                                                                                    let l26 = *base.add(17*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                                    let l27 = *base.add(18*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                    _rt::cabi_dealloc(l26, l27, 1);
                                                                                                                                                    let l28 = i32::from(*base.add(16+20*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                                                    match l28 {
                                                                                                                                                      0 => (),
                                                                                                                                                      _ => {
                                                                                                                                                        let l29 = *base.add(16+21*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                                        let l30 = *base.add(16+22*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                        _rt::cabi_dealloc(l29, l30, 1);
                                                                                                                                                      },
                                                                                                                                                    }
                                                                                                                                                  },
                                                                                                                                                }
                                                                                                                                                let l31 = i32::from(*base.add(16+23*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                                                match l31 {
                                                                                                                                                  0 => (),
                                                                                                                                                  _ => {
                                                                                                                                                    let l32 = *base.add(16+24*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                                    let l33 = *base.add(16+25*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                    _rt::cabi_dealloc(l32, l33, 1);
                                                                                                                                                    let l34 = i32::from(*base.add(32+27*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                                                    match l34 {
                                                                                                                                                      0 => (),
                                                                                                                                                      _ => {
                                                                                                                                                        let l35 = *base.add(32+28*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                                        let l36 = *base.add(32+29*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                        _rt::cabi_dealloc(l35, l36, 1);
                                                                                                                                                      },
                                                                                                                                                    }
                                                                                                                                                  },
                                                                                                                                                }
                                                                                                                                                let l37 = i32::from(*base.add(32+30*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                                                match l37 {
                                                                                                                                                  0 => (),
                                                                                                                                                  _ => {
                                                                                                                                                    let l38 = *base.add(32+31*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                                    let l39 = *base.add(32+32*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                    _rt::cabi_dealloc(l38, l39, 1);
                                                                                                                                                    let l40 = i32::from(*base.add(48+34*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                                                    match l40 {
                                                                                                                                                      0 => (),
                                                                                                                                                      _ => {
                                                                                                                                                        let l41 = *base.add(48+35*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                                        let l42 = *base.add(48+36*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                        _rt::cabi_dealloc(l41, l42, 1);
                                                                                                                                                      },
                                                                                                                                                    }
                                                                                                                                                  },
                                                                                                                                                }
                                                                                                                                                let l43 = i32::from(*base.add(48+37*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                                                match l43 {
                                                                                                                                                  0 => (),
                                                                                                                                                  _ => {
                                                                                                                                                    let l44 = *base.add(48+38*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                                    let l45 = *base.add(48+39*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                    _rt::cabi_dealloc(l44, l45, 1);
                                                                                                                                                    let l46 = i32::from(*base.add(64+41*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                                                    match l46 {
                                                                                                                                                      0 => (),
                                                                                                                                                      _ => {
                                                                                                                                                        let l47 = *base.add(64+42*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                                        let l48 = *base.add(64+43*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                        _rt::cabi_dealloc(l47, l48, 1);
                                                                                                                                                      },
                                                                                                                                                    }
                                                                                                                                                  },
                                                                                                                                                }
                                                                                                                                                let l49 = i32::from(*base.add(64+44*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                                                match l49 {
                                                                                                                                                  0 => (),
                                                                                                                                                  _ => {
                                                                                                                                                    let l50 = *base.add(64+45*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                                    let l51 = *base.add(64+46*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                    _rt::cabi_dealloc(l50, l51, 1);
                                                                                                                                                    let l52 = i32::from(*base.add(80+48*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                                                    match l52 {
                                                                                                                                                      0 => (),
                                                                                                                                                      _ => {
                                                                                                                                                        let l53 = *base.add(80+49*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                                        let l54 = *base.add(80+50*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                        _rt::cabi_dealloc(l53, l54, 1);
                                                                                                                                                      },
                                                                                                                                                    }
                                                                                                                                                  },
                                                                                                                                                }
                                                                                                                                              },
                                                                                                                                            }
                                                                                                                                            let l55 = *base.add(80+51*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                            let l56 = *base.add(80+52*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                            let base59 = l55;
                                                                                                                                            let len59 = l56;
                                                                                                                                            for i in 0..len59 {
                                                                                                                                              let base = base59.add(i * (2*::core::mem::size_of::<*const u8>()));
                                                                                                                                              {
                                                                                                                                                let l57 = *base.add(0).cast::<*mut u8>();
                                                                                                                                                let l58 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                _rt::cabi_dealloc(l57, l58, 1);
                                                                                                                                              }
                                                                                                                                            }
                                                                                                                                            _rt::cabi_dealloc(base59, len59 * (2*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                                                                                                                            let l60 = *base.add(80+53*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                            let l61 = *base.add(80+54*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                            let base66 = l60;
                                                                                                                                            let len66 = l61;
                                                                                                                                            for i in 0..len66 {
                                                                                                                                              let base = base66.add(i * (4*::core::mem::size_of::<*const u8>()));
                                                                                                                                              {
                                                                                                                                                let l62 = *base.add(0).cast::<*mut u8>();
                                                                                                                                                let l63 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                _rt::cabi_dealloc(l62, l63, 1);
                                                                                                                                                let l64 = *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                                let l65 = *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                _rt::cabi_dealloc(l64, l65, 1);
                                                                                                                                              }
                                                                                                                                            }
                                                                                                                                            _rt::cabi_dealloc(base66, len66 * (4*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                                                                                                                          }
                                                                                                                                        }
                                                                                                                                        _rt::cabi_dealloc(base67, len67 * (80+55*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                                                                                                                        let l68 = i32::from(*base.add(6*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                                        match l68 {
                                                                                                                                          0 => (),
                                                                                                                                          _ => {
                                                                                                                                            let l69 = *base.add(7*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                            let l70 = *base.add(8*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                            _rt::cabi_dealloc(l69, l70, 1);
                                                                                                                                          },
                                                                                                                                        }
                                                                                                                                      }
                                                                                                                                    }
                                                                                                                                    _rt::cabi_dealloc(base71, len71 * (9*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                                                                                                                  },
                                                                                                                                  _ => {
                                                                                                                                    let l72 = i32::from(*arg0.add(::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                                    match l72 {
                                                                                                                                      0 => {
                                                                                                                                        let l73 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                        let l74 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                        _rt::cabi_dealloc(l73, l74, 1);
                                                                                                                                      },
                                                                                                                                      1 => {
                                                                                                                                        let l75 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                        let l76 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                        _rt::cabi_dealloc(l75, l76, 1);
                                                                                                                                      },
                                                                                                                                      2 => (),
                                                                                                                                      3 => (),
                                                                                                                                      4 => (),
                                                                                                                                      5 => (),
                                                                                                                                      6 => (),
                                                                                                                                      7 => (),
                                                                                                                                      8 => (),
                                                                                                                                      9 => {
                                                                                                                                        let l77 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                        let l78 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                        _rt::cabi_dealloc(l77, l78, 1);
                                                                                                                                      },
                                                                                                                                      _ => {
                                                                                                                                        let l79 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                        let l80 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                        _rt::cabi_dealloc(l79, l80, 1);
                                                                                                                                      },
                                                                                                                                    }
                                                                                                                                  },
                                                                                                                                }
                                                                                                                              } }
                                                                                                                              #[doc(hidden)]
                                                                                                                              #[allow(non_snake_case, unused_unsafe)]
                                                                                                                              pub unsafe fn _export_search_articles_cabi<T_: Guest>(arg0: *mut u8,arg1: usize,arg2: i32,arg3: *mut u8,arg4: usize,arg5: i32,arg6: *mut u8,arg7: usize,arg8: i32,arg9: *mut u8,arg10: usize,arg11: *mut u8,arg12: usize,) -> *mut u8 { unsafe {#[cfg(target_arch="wasm32")]
                                                                                                                              _rt::run_ctors_once();let result8 = {
                                                                                                                                let len0 = arg1;
                                                                                                                                let bytes0 = _rt::Vec::from_raw_parts(arg0.cast(), len0, len0);
                                                                                                                                let base6 = arg9;
                                                                                                                                let len6 = arg10;
                                                                                                                                let mut result6 = _rt::Vec::with_capacity(len6);
                                                                                                                                for i in 0..len6 {
                                                                                                                                  let base = base6.add(i * (2*::core::mem::size_of::<*const u8>()));
                                                                                                                                  let e6 = {
                                                                                                                                    let l3 = *base.add(0).cast::<*mut u8>();
                                                                                                                                    let l4 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                    let len5 = l4;
                                                                                                                                    let bytes5 = _rt::Vec::from_raw_parts(l3.cast(), len5, len5);

                                                                                                                                    _rt::string_lift(bytes5)
                                                                                                                                  };
                                                                                                                                  result6.push(e6);
                                                                                                                                }
                                                                                                                                _rt::cabi_dealloc(base6, len6 * (2*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                                                                                                                let len7 = arg12;
                                                                                                                                let bytes7 = _rt::Vec::from_raw_parts(arg11.cast(), len7, len7);
                                                                                                                                T_::search_articles(super::super::bex::plugin::common::RequestContext{
                                                                                                                                  request_id: _rt::string_lift(bytes0),
                                                                                                                                  locale: match arg2 {
                                                                                                                                    0 => None,
                                                                                                                                    1 => {
                                                                                                                                      let e = {
                                                                                                                                        let len1 = arg4;
                                                                                                                                        let bytes1 = _rt::Vec::from_raw_parts(arg3.cast(), len1, len1);

                                                                                                                                        _rt::string_lift(bytes1)
                                                                                                                                      };
                                                                                                                                      Some(e)
                                                                                                                                    }
                                                                                                                                    _ => _rt::invalid_enum_discriminant(),
                                                                                                                                  },
                                                                                                                                  region: match arg5 {
                                                                                                                                    0 => None,
                                                                                                                                    1 => {
                                                                                                                                      let e = {
                                                                                                                                        let len2 = arg7;
                                                                                                                                        let bytes2 = _rt::Vec::from_raw_parts(arg6.cast(), len2, len2);

                                                                                                                                        _rt::string_lift(bytes2)
                                                                                                                                      };
                                                                                                                                      Some(e)
                                                                                                                                    }
                                                                                                                                    _ => _rt::invalid_enum_discriminant(),
                                                                                                                                  },
                                                                                                                                  safe_mode: _rt::bool_lift(arg8 as u8),
                                                                                                                                  hints: result6,
                                                                                                                                }, _rt::string_lift(bytes7))
                                                                                                                              };
                                                                                                                              let ptr9 = (&raw mut _RET_AREA.0).cast::<u8>();
                                                                                                                              match result8 {
                                                                                                                                Ok(e) => { {
                                                                                                                                  *ptr9.add(0).cast::<u8>() = (0i32) as u8;
                                                                                                                                  let vec39 = e;
                                                                                                                                  let len39 = vec39.len();
                                                                                                                                  let layout39 = _rt::alloc::Layout::from_size_align(vec39.len() * (80+55*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>()).unwrap();
                                                                                                                                  let (result39, _cleanup39) = wit_bindgen::rt::Cleanup::new(layout39);if let Some(cleanup) = _cleanup39 { cleanup.forget(); }
                                                                                                                                  for (i, e) in vec39.into_iter().enumerate() {
                                                                                                                                    let base = result39.add(i * (80+55*::core::mem::size_of::<*const u8>()));
                                                                                                                                    {
                                                                                                                                      let super::super::bex::plugin::common::Article{ id:id10, title:title10, summary:summary10, url:url10, published:published10, author:author10, thumbnail:thumbnail10, tags:tags10, extra:extra10, } = e;
                                                                                                                                      let vec11 = (id10.into_bytes()).into_boxed_slice();
                                                                                                                                      let ptr11 = vec11.as_ptr().cast::<u8>();
                                                                                                                                      let len11 = vec11.len();
                                                                                                                                      ::core::mem::forget(vec11);
                                                                                                                                      *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len11;
                                                                                                                                      *base.add(0).cast::<*mut u8>() = ptr11.cast_mut();
                                                                                                                                      let vec12 = (title10.into_bytes()).into_boxed_slice();
                                                                                                                                      let ptr12 = vec12.as_ptr().cast::<u8>();
                                                                                                                                      let len12 = vec12.len();
                                                                                                                                      ::core::mem::forget(vec12);
                                                                                                                                      *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len12;
                                                                                                                                      *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr12.cast_mut();
                                                                                                                                      match summary10 {
                                                                                                                                        Some(e) => {
                                                                                                                                          *base.add(4*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                          let vec13 = (e.into_bytes()).into_boxed_slice();
                                                                                                                                          let ptr13 = vec13.as_ptr().cast::<u8>();
                                                                                                                                          let len13 = vec13.len();
                                                                                                                                          ::core::mem::forget(vec13);
                                                                                                                                          *base.add(6*::core::mem::size_of::<*const u8>()).cast::<usize>() = len13;
                                                                                                                                          *base.add(5*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr13.cast_mut();
                                                                                                                                        },
                                                                                                                                        None => {
                                                                                                                                          {
                                                                                                                                            *base.add(4*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                          }
                                                                                                                                        },
                                                                                                                                      };let vec14 = (url10.into_bytes()).into_boxed_slice();
                                                                                                                                      let ptr14 = vec14.as_ptr().cast::<u8>();
                                                                                                                                      let len14 = vec14.len();
                                                                                                                                      ::core::mem::forget(vec14);
                                                                                                                                      *base.add(8*::core::mem::size_of::<*const u8>()).cast::<usize>() = len14;
                                                                                                                                      *base.add(7*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr14.cast_mut();
                                                                                                                                      match published10 {
                                                                                                                                        Some(e) => {
                                                                                                                                          *base.add(9*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                          let vec15 = (e.into_bytes()).into_boxed_slice();
                                                                                                                                          let ptr15 = vec15.as_ptr().cast::<u8>();
                                                                                                                                          let len15 = vec15.len();
                                                                                                                                          ::core::mem::forget(vec15);
                                                                                                                                          *base.add(11*::core::mem::size_of::<*const u8>()).cast::<usize>() = len15;
                                                                                                                                          *base.add(10*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr15.cast_mut();
                                                                                                                                        },
                                                                                                                                        None => {
                                                                                                                                          {
                                                                                                                                            *base.add(9*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                          }
                                                                                                                                        },
                                                                                                                                      };match author10 {
                                                                                                                                        Some(e) => {
                                                                                                                                          *base.add(12*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                          let vec16 = (e.into_bytes()).into_boxed_slice();
                                                                                                                                          let ptr16 = vec16.as_ptr().cast::<u8>();
                                                                                                                                          let len16 = vec16.len();
                                                                                                                                          ::core::mem::forget(vec16);
                                                                                                                                          *base.add(14*::core::mem::size_of::<*const u8>()).cast::<usize>() = len16;
                                                                                                                                          *base.add(13*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr16.cast_mut();
                                                                                                                                        },
                                                                                                                                        None => {
                                                                                                                                          {
                                                                                                                                            *base.add(12*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                          }
                                                                                                                                        },
                                                                                                                                      };match thumbnail10 {
                                                                                                                                        Some(e) => {
                                                                                                                                          *base.add(15*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                          let super::super::bex::plugin::common::ImageSet{ low:low17, medium:medium17, high:high17, backdrop:backdrop17, logo:logo17, } = e;
                                                                                                                                          match low17 {
                                                                                                                                            Some(e) => {
                                                                                                                                              *base.add(16*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                              let super::super::bex::plugin::common::Image{ url:url18, layout:layout18, width:width18, height:height18, blurhash:blurhash18, } = e;
                                                                                                                                              let vec19 = (url18.into_bytes()).into_boxed_slice();
                                                                                                                                              let ptr19 = vec19.as_ptr().cast::<u8>();
                                                                                                                                              let len19 = vec19.len();
                                                                                                                                              ::core::mem::forget(vec19);
                                                                                                                                              *base.add(18*::core::mem::size_of::<*const u8>()).cast::<usize>() = len19;
                                                                                                                                              *base.add(17*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr19.cast_mut();
                                                                                                                                              *base.add(19*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout18.clone() as i32) as u8;
                                                                                                                                              match width18 {
                                                                                                                                                Some(e) => {
                                                                                                                                                  *base.add(4+19*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                                  *base.add(8+19*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                                                                },
                                                                                                                                                None => {
                                                                                                                                                  {
                                                                                                                                                    *base.add(4+19*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                                  }
                                                                                                                                                },
                                                                                                                                              };match height18 {
                                                                                                                                                Some(e) => {
                                                                                                                                                  *base.add(12+19*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                                  *base.add(16+19*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                                                                },
                                                                                                                                                None => {
                                                                                                                                                  {
                                                                                                                                                    *base.add(12+19*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                                  }
                                                                                                                                                },
                                                                                                                                              };match blurhash18 {
                                                                                                                                                Some(e) => {
                                                                                                                                                  *base.add(16+20*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                                  let vec20 = (e.into_bytes()).into_boxed_slice();
                                                                                                                                                  let ptr20 = vec20.as_ptr().cast::<u8>();
                                                                                                                                                  let len20 = vec20.len();
                                                                                                                                                  ::core::mem::forget(vec20);
                                                                                                                                                  *base.add(16+22*::core::mem::size_of::<*const u8>()).cast::<usize>() = len20;
                                                                                                                                                  *base.add(16+21*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr20.cast_mut();
                                                                                                                                                },
                                                                                                                                                None => {
                                                                                                                                                  {
                                                                                                                                                    *base.add(16+20*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                                  }
                                                                                                                                                },
                                                                                                                                              };},
                                                                                                                                              None => {
                                                                                                                                                {
                                                                                                                                                  *base.add(16*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                                }
                                                                                                                                              },
                                                                                                                                            };match medium17 {
                                                                                                                                              Some(e) => {
                                                                                                                                                *base.add(16+23*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                                let super::super::bex::plugin::common::Image{ url:url21, layout:layout21, width:width21, height:height21, blurhash:blurhash21, } = e;
                                                                                                                                                let vec22 = (url21.into_bytes()).into_boxed_slice();
                                                                                                                                                let ptr22 = vec22.as_ptr().cast::<u8>();
                                                                                                                                                let len22 = vec22.len();
                                                                                                                                                ::core::mem::forget(vec22);
                                                                                                                                                *base.add(16+25*::core::mem::size_of::<*const u8>()).cast::<usize>() = len22;
                                                                                                                                                *base.add(16+24*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr22.cast_mut();
                                                                                                                                                *base.add(16+26*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout21.clone() as i32) as u8;
                                                                                                                                                match width21 {
                                                                                                                                                  Some(e) => {
                                                                                                                                                    *base.add(20+26*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                                    *base.add(24+26*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                                                                  },
                                                                                                                                                  None => {
                                                                                                                                                    {
                                                                                                                                                      *base.add(20+26*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                                    }
                                                                                                                                                  },
                                                                                                                                                };match height21 {
                                                                                                                                                  Some(e) => {
                                                                                                                                                    *base.add(28+26*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                                    *base.add(32+26*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                                                                  },
                                                                                                                                                  None => {
                                                                                                                                                    {
                                                                                                                                                      *base.add(28+26*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                                    }
                                                                                                                                                  },
                                                                                                                                                };match blurhash21 {
                                                                                                                                                  Some(e) => {
                                                                                                                                                    *base.add(32+27*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                                    let vec23 = (e.into_bytes()).into_boxed_slice();
                                                                                                                                                    let ptr23 = vec23.as_ptr().cast::<u8>();
                                                                                                                                                    let len23 = vec23.len();
                                                                                                                                                    ::core::mem::forget(vec23);
                                                                                                                                                    *base.add(32+29*::core::mem::size_of::<*const u8>()).cast::<usize>() = len23;
                                                                                                                                                    *base.add(32+28*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr23.cast_mut();
                                                                                                                                                  },
                                                                                                                                                  None => {
                                                                                                                                                    {
                                                                                                                                                      *base.add(32+27*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                                    }
                                                                                                                                                  },
                                                                                                                                                };},
                                                                                                                                                None => {
                                                                                                                                                  {
                                                                                                                                                    *base.add(16+23*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                                  }
                                                                                                                                                },
                                                                                                                                              };match high17 {
                                                                                                                                                Some(e) => {
                                                                                                                                                  *base.add(32+30*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                                  let super::super::bex::plugin::common::Image{ url:url24, layout:layout24, width:width24, height:height24, blurhash:blurhash24, } = e;
                                                                                                                                                  let vec25 = (url24.into_bytes()).into_boxed_slice();
                                                                                                                                                  let ptr25 = vec25.as_ptr().cast::<u8>();
                                                                                                                                                  let len25 = vec25.len();
                                                                                                                                                  ::core::mem::forget(vec25);
                                                                                                                                                  *base.add(32+32*::core::mem::size_of::<*const u8>()).cast::<usize>() = len25;
                                                                                                                                                  *base.add(32+31*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr25.cast_mut();
                                                                                                                                                  *base.add(32+33*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout24.clone() as i32) as u8;
                                                                                                                                                  match width24 {
                                                                                                                                                    Some(e) => {
                                                                                                                                                      *base.add(36+33*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                                      *base.add(40+33*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                                                                    },
                                                                                                                                                    None => {
                                                                                                                                                      {
                                                                                                                                                        *base.add(36+33*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                                      }
                                                                                                                                                    },
                                                                                                                                                  };match height24 {
                                                                                                                                                    Some(e) => {
                                                                                                                                                      *base.add(44+33*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                                      *base.add(48+33*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                                                                    },
                                                                                                                                                    None => {
                                                                                                                                                      {
                                                                                                                                                        *base.add(44+33*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                                      }
                                                                                                                                                    },
                                                                                                                                                  };match blurhash24 {
                                                                                                                                                    Some(e) => {
                                                                                                                                                      *base.add(48+34*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                                      let vec26 = (e.into_bytes()).into_boxed_slice();
                                                                                                                                                      let ptr26 = vec26.as_ptr().cast::<u8>();
                                                                                                                                                      let len26 = vec26.len();
                                                                                                                                                      ::core::mem::forget(vec26);
                                                                                                                                                      *base.add(48+36*::core::mem::size_of::<*const u8>()).cast::<usize>() = len26;
                                                                                                                                                      *base.add(48+35*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr26.cast_mut();
                                                                                                                                                    },
                                                                                                                                                    None => {
                                                                                                                                                      {
                                                                                                                                                        *base.add(48+34*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                                      }
                                                                                                                                                    },
                                                                                                                                                  };},
                                                                                                                                                  None => {
                                                                                                                                                    {
                                                                                                                                                      *base.add(32+30*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                                    }
                                                                                                                                                  },
                                                                                                                                                };match backdrop17 {
                                                                                                                                                  Some(e) => {
                                                                                                                                                    *base.add(48+37*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                                    let super::super::bex::plugin::common::Image{ url:url27, layout:layout27, width:width27, height:height27, blurhash:blurhash27, } = e;
                                                                                                                                                    let vec28 = (url27.into_bytes()).into_boxed_slice();
                                                                                                                                                    let ptr28 = vec28.as_ptr().cast::<u8>();
                                                                                                                                                    let len28 = vec28.len();
                                                                                                                                                    ::core::mem::forget(vec28);
                                                                                                                                                    *base.add(48+39*::core::mem::size_of::<*const u8>()).cast::<usize>() = len28;
                                                                                                                                                    *base.add(48+38*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr28.cast_mut();
                                                                                                                                                    *base.add(48+40*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout27.clone() as i32) as u8;
                                                                                                                                                    match width27 {
                                                                                                                                                      Some(e) => {
                                                                                                                                                        *base.add(52+40*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                                        *base.add(56+40*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                                                                      },
                                                                                                                                                      None => {
                                                                                                                                                        {
                                                                                                                                                          *base.add(52+40*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                                        }
                                                                                                                                                      },
                                                                                                                                                    };match height27 {
                                                                                                                                                      Some(e) => {
                                                                                                                                                        *base.add(60+40*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                                        *base.add(64+40*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                                                                      },
                                                                                                                                                      None => {
                                                                                                                                                        {
                                                                                                                                                          *base.add(60+40*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                                        }
                                                                                                                                                      },
                                                                                                                                                    };match blurhash27 {
                                                                                                                                                      Some(e) => {
                                                                                                                                                        *base.add(64+41*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                                        let vec29 = (e.into_bytes()).into_boxed_slice();
                                                                                                                                                        let ptr29 = vec29.as_ptr().cast::<u8>();
                                                                                                                                                        let len29 = vec29.len();
                                                                                                                                                        ::core::mem::forget(vec29);
                                                                                                                                                        *base.add(64+43*::core::mem::size_of::<*const u8>()).cast::<usize>() = len29;
                                                                                                                                                        *base.add(64+42*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr29.cast_mut();
                                                                                                                                                      },
                                                                                                                                                      None => {
                                                                                                                                                        {
                                                                                                                                                          *base.add(64+41*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                                        }
                                                                                                                                                      },
                                                                                                                                                    };},
                                                                                                                                                    None => {
                                                                                                                                                      {
                                                                                                                                                        *base.add(48+37*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                                      }
                                                                                                                                                    },
                                                                                                                                                  };match logo17 {
                                                                                                                                                    Some(e) => {
                                                                                                                                                      *base.add(64+44*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                                      let super::super::bex::plugin::common::Image{ url:url30, layout:layout30, width:width30, height:height30, blurhash:blurhash30, } = e;
                                                                                                                                                      let vec31 = (url30.into_bytes()).into_boxed_slice();
                                                                                                                                                      let ptr31 = vec31.as_ptr().cast::<u8>();
                                                                                                                                                      let len31 = vec31.len();
                                                                                                                                                      ::core::mem::forget(vec31);
                                                                                                                                                      *base.add(64+46*::core::mem::size_of::<*const u8>()).cast::<usize>() = len31;
                                                                                                                                                      *base.add(64+45*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr31.cast_mut();
                                                                                                                                                      *base.add(64+47*::core::mem::size_of::<*const u8>()).cast::<u8>() = (layout30.clone() as i32) as u8;
                                                                                                                                                      match width30 {
                                                                                                                                                        Some(e) => {
                                                                                                                                                          *base.add(68+47*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                                          *base.add(72+47*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                                                                        },
                                                                                                                                                        None => {
                                                                                                                                                          {
                                                                                                                                                            *base.add(68+47*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                                          }
                                                                                                                                                        },
                                                                                                                                                      };match height30 {
                                                                                                                                                        Some(e) => {
                                                                                                                                                          *base.add(76+47*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                                          *base.add(80+47*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                                                                        },
                                                                                                                                                        None => {
                                                                                                                                                          {
                                                                                                                                                            *base.add(76+47*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                                          }
                                                                                                                                                        },
                                                                                                                                                      };match blurhash30 {
                                                                                                                                                        Some(e) => {
                                                                                                                                                          *base.add(80+48*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                                          let vec32 = (e.into_bytes()).into_boxed_slice();
                                                                                                                                                          let ptr32 = vec32.as_ptr().cast::<u8>();
                                                                                                                                                          let len32 = vec32.len();
                                                                                                                                                          ::core::mem::forget(vec32);
                                                                                                                                                          *base.add(80+50*::core::mem::size_of::<*const u8>()).cast::<usize>() = len32;
                                                                                                                                                          *base.add(80+49*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr32.cast_mut();
                                                                                                                                                        },
                                                                                                                                                        None => {
                                                                                                                                                          {
                                                                                                                                                            *base.add(80+48*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                                          }
                                                                                                                                                        },
                                                                                                                                                      };},
                                                                                                                                                      None => {
                                                                                                                                                        {
                                                                                                                                                          *base.add(64+44*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                                        }
                                                                                                                                                      },
                                                                                                                                                    };},
                                                                                                                                                    None => {
                                                                                                                                                      {
                                                                                                                                                        *base.add(15*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                                      }
                                                                                                                                                    },
                                                                                                                                                  };let vec34 = tags10;
                                                                                                                                                  let len34 = vec34.len();
                                                                                                                                                  let layout34 = _rt::alloc::Layout::from_size_align(vec34.len() * (2*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>()).unwrap();
                                                                                                                                                  let (result34, _cleanup34) = wit_bindgen::rt::Cleanup::new(layout34);if let Some(cleanup) = _cleanup34 { cleanup.forget(); }
                                                                                                                                                  for (i, e) in vec34.into_iter().enumerate() {
                                                                                                                                                    let base = result34.add(i * (2*::core::mem::size_of::<*const u8>()));
                                                                                                                                                    {
                                                                                                                                                      let vec33 = (e.into_bytes()).into_boxed_slice();
                                                                                                                                                      let ptr33 = vec33.as_ptr().cast::<u8>();
                                                                                                                                                      let len33 = vec33.len();
                                                                                                                                                      ::core::mem::forget(vec33);
                                                                                                                                                      *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len33;
                                                                                                                                                      *base.add(0).cast::<*mut u8>() = ptr33.cast_mut();
                                                                                                                                                    }
                                                                                                                                                  }
                                                                                                                                                  *base.add(80+52*::core::mem::size_of::<*const u8>()).cast::<usize>() = len34;
                                                                                                                                                  *base.add(80+51*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result34;
                                                                                                                                                  let vec38 = extra10;
                                                                                                                                                  let len38 = vec38.len();
                                                                                                                                                  let layout38 = _rt::alloc::Layout::from_size_align(vec38.len() * (4*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>()).unwrap();
                                                                                                                                                  let (result38, _cleanup38) = wit_bindgen::rt::Cleanup::new(layout38);if let Some(cleanup) = _cleanup38 { cleanup.forget(); }
                                                                                                                                                  for (i, e) in vec38.into_iter().enumerate() {
                                                                                                                                                    let base = result38.add(i * (4*::core::mem::size_of::<*const u8>()));
                                                                                                                                                    {
                                                                                                                                                      let super::super::bex::plugin::common::Attr{ key:key35, value:value35, } = e;
                                                                                                                                                      let vec36 = (key35.into_bytes()).into_boxed_slice();
                                                                                                                                                      let ptr36 = vec36.as_ptr().cast::<u8>();
                                                                                                                                                      let len36 = vec36.len();
                                                                                                                                                      ::core::mem::forget(vec36);
                                                                                                                                                      *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>() = len36;
                                                                                                                                                      *base.add(0).cast::<*mut u8>() = ptr36.cast_mut();
                                                                                                                                                      let vec37 = (value35.into_bytes()).into_boxed_slice();
                                                                                                                                                      let ptr37 = vec37.as_ptr().cast::<u8>();
                                                                                                                                                      let len37 = vec37.len();
                                                                                                                                                      ::core::mem::forget(vec37);
                                                                                                                                                      *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len37;
                                                                                                                                                      *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr37.cast_mut();
                                                                                                                                                    }
                                                                                                                                                  }
                                                                                                                                                  *base.add(80+54*::core::mem::size_of::<*const u8>()).cast::<usize>() = len38;
                                                                                                                                                  *base.add(80+53*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result38;
                                                                                                                                                }
                                                                                                                                              }
                                                                                                                                              *ptr9.add(2*::core::mem::size_of::<*const u8>()).cast::<usize>() = len39;
                                                                                                                                              *ptr9.add(::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = result39;
                                                                                                                                            } },
                                                                                                                                            Err(e) => { {
                                                                                                                                              *ptr9.add(0).cast::<u8>() = (1i32) as u8;
                                                                                                                                              use super::super::bex::plugin::common::PluginError as V44;
                                                                                                                                              match e {
                                                                                                                                                V44::Network(e) => {
                                                                                                                                                  *ptr9.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                                  let vec40 = (e.into_bytes()).into_boxed_slice();
                                                                                                                                                  let ptr40 = vec40.as_ptr().cast::<u8>();
                                                                                                                                                  let len40 = vec40.len();
                                                                                                                                                  ::core::mem::forget(vec40);
                                                                                                                                                  *ptr9.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len40;
                                                                                                                                                  *ptr9.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr40.cast_mut();
                                                                                                                                                },
                                                                                                                                                V44::Parse(e) => {
                                                                                                                                                  *ptr9.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                                  let vec41 = (e.into_bytes()).into_boxed_slice();
                                                                                                                                                  let ptr41 = vec41.as_ptr().cast::<u8>();
                                                                                                                                                  let len41 = vec41.len();
                                                                                                                                                  ::core::mem::forget(vec41);
                                                                                                                                                  *ptr9.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len41;
                                                                                                                                                  *ptr9.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr41.cast_mut();
                                                                                                                                                },
                                                                                                                                                V44::NotFound=> {
                                                                                                                                                  {
                                                                                                                                                    *ptr9.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (2i32) as u8;
                                                                                                                                                  }
                                                                                                                                                }
                                                                                                                                                V44::Unauthorized=> {
                                                                                                                                                  {
                                                                                                                                                    *ptr9.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (3i32) as u8;
                                                                                                                                                  }
                                                                                                                                                }
                                                                                                                                                V44::Forbidden=> {
                                                                                                                                                  {
                                                                                                                                                    *ptr9.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (4i32) as u8;
                                                                                                                                                  }
                                                                                                                                                }
                                                                                                                                                V44::RateLimited(e) => {
                                                                                                                                                  *ptr9.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (5i32) as u8;
                                                                                                                                                  match e {
                                                                                                                                                    Some(e) => {
                                                                                                                                                      *ptr9.add(2*::core::mem::size_of::<*const u8>()).cast::<u8>() = (1i32) as u8;
                                                                                                                                                      *ptr9.add(4+2*::core::mem::size_of::<*const u8>()).cast::<i32>() = _rt::as_i32(e);
                                                                                                                                                    },
                                                                                                                                                    None => {
                                                                                                                                                      {
                                                                                                                                                        *ptr9.add(2*::core::mem::size_of::<*const u8>()).cast::<u8>() = (0i32) as u8;
                                                                                                                                                      }
                                                                                                                                                    },
                                                                                                                                                  };},
                                                                                                                                                  V44::Timeout=> {
                                                                                                                                                    {
                                                                                                                                                      *ptr9.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (6i32) as u8;
                                                                                                                                                    }
                                                                                                                                                  }
                                                                                                                                                  V44::Cancelled=> {
                                                                                                                                                    {
                                                                                                                                                      *ptr9.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (7i32) as u8;
                                                                                                                                                    }
                                                                                                                                                  }
                                                                                                                                                  V44::Unsupported=> {
                                                                                                                                                    {
                                                                                                                                                      *ptr9.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (8i32) as u8;
                                                                                                                                                    }
                                                                                                                                                  }
                                                                                                                                                  V44::InvalidInput(e) => {
                                                                                                                                                    *ptr9.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (9i32) as u8;
                                                                                                                                                    let vec42 = (e.into_bytes()).into_boxed_slice();
                                                                                                                                                    let ptr42 = vec42.as_ptr().cast::<u8>();
                                                                                                                                                    let len42 = vec42.len();
                                                                                                                                                    ::core::mem::forget(vec42);
                                                                                                                                                    *ptr9.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len42;
                                                                                                                                                    *ptr9.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr42.cast_mut();
                                                                                                                                                  },
                                                                                                                                                  V44::Internal(e) => {
                                                                                                                                                    *ptr9.add(::core::mem::size_of::<*const u8>()).cast::<u8>() = (10i32) as u8;
                                                                                                                                                    let vec43 = (e.into_bytes()).into_boxed_slice();
                                                                                                                                                    let ptr43 = vec43.as_ptr().cast::<u8>();
                                                                                                                                                    let len43 = vec43.len();
                                                                                                                                                    ::core::mem::forget(vec43);
                                                                                                                                                    *ptr9.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>() = len43;
                                                                                                                                                    *ptr9.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>() = ptr43.cast_mut();
                                                                                                                                                  },
                                                                                                                                                }
                                                                                                                                              } },
                                                                                                                                            };ptr9
                                                                                                                                          } }
                                                                                                                                          #[doc(hidden)]
                                                                                                                                          #[allow(non_snake_case)]
                                                                                                                                          pub unsafe fn __post_return_search_articles<T_: Guest>(arg0: *mut u8,) { unsafe {
                                                                                                                                            let l0 = i32::from(*arg0.add(0).cast::<u8>());
                                                                                                                                            match l0 {
                                                                                                                                              0 => {
                                                                                                                                                let l1 = *arg0.add(::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                                let l2 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                let base61 = l1;
                                                                                                                                                let len61 = l2;
                                                                                                                                                for i in 0..len61 {
                                                                                                                                                  let base = base61.add(i * (80+55*::core::mem::size_of::<*const u8>()));
                                                                                                                                                  {
                                                                                                                                                    let l3 = *base.add(0).cast::<*mut u8>();
                                                                                                                                                    let l4 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                    _rt::cabi_dealloc(l3, l4, 1);
                                                                                                                                                    let l5 = *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                                    let l6 = *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                    _rt::cabi_dealloc(l5, l6, 1);
                                                                                                                                                    let l7 = i32::from(*base.add(4*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                                                    match l7 {
                                                                                                                                                      0 => (),
                                                                                                                                                      _ => {
                                                                                                                                                        let l8 = *base.add(5*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                                        let l9 = *base.add(6*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                        _rt::cabi_dealloc(l8, l9, 1);
                                                                                                                                                      },
                                                                                                                                                    }
                                                                                                                                                    let l10 = *base.add(7*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                                    let l11 = *base.add(8*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                    _rt::cabi_dealloc(l10, l11, 1);
                                                                                                                                                    let l12 = i32::from(*base.add(9*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                                                    match l12 {
                                                                                                                                                      0 => (),
                                                                                                                                                      _ => {
                                                                                                                                                        let l13 = *base.add(10*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                                        let l14 = *base.add(11*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                        _rt::cabi_dealloc(l13, l14, 1);
                                                                                                                                                      },
                                                                                                                                                    }
                                                                                                                                                    let l15 = i32::from(*base.add(12*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                                                    match l15 {
                                                                                                                                                      0 => (),
                                                                                                                                                      _ => {
                                                                                                                                                        let l16 = *base.add(13*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                                        let l17 = *base.add(14*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                        _rt::cabi_dealloc(l16, l17, 1);
                                                                                                                                                      },
                                                                                                                                                    }
                                                                                                                                                    let l18 = i32::from(*base.add(15*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                                                    match l18 {
                                                                                                                                                      0 => (),
                                                                                                                                                      _ => {
                                                                                                                                                        let l19 = i32::from(*base.add(16*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                                                        match l19 {
                                                                                                                                                          0 => (),
                                                                                                                                                          _ => {
                                                                                                                                                            let l20 = *base.add(17*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                                            let l21 = *base.add(18*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                            _rt::cabi_dealloc(l20, l21, 1);
                                                                                                                                                            let l22 = i32::from(*base.add(16+20*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                                                            match l22 {
                                                                                                                                                              0 => (),
                                                                                                                                                              _ => {
                                                                                                                                                                let l23 = *base.add(16+21*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                                                let l24 = *base.add(16+22*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                                _rt::cabi_dealloc(l23, l24, 1);
                                                                                                                                                              },
                                                                                                                                                            }
                                                                                                                                                          },
                                                                                                                                                        }
                                                                                                                                                        let l25 = i32::from(*base.add(16+23*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                                                        match l25 {
                                                                                                                                                          0 => (),
                                                                                                                                                          _ => {
                                                                                                                                                            let l26 = *base.add(16+24*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                                            let l27 = *base.add(16+25*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                            _rt::cabi_dealloc(l26, l27, 1);
                                                                                                                                                            let l28 = i32::from(*base.add(32+27*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                                                            match l28 {
                                                                                                                                                              0 => (),
                                                                                                                                                              _ => {
                                                                                                                                                                let l29 = *base.add(32+28*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                                                let l30 = *base.add(32+29*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                                _rt::cabi_dealloc(l29, l30, 1);
                                                                                                                                                              },
                                                                                                                                                            }
                                                                                                                                                          },
                                                                                                                                                        }
                                                                                                                                                        let l31 = i32::from(*base.add(32+30*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                                                        match l31 {
                                                                                                                                                          0 => (),
                                                                                                                                                          _ => {
                                                                                                                                                            let l32 = *base.add(32+31*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                                            let l33 = *base.add(32+32*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                            _rt::cabi_dealloc(l32, l33, 1);
                                                                                                                                                            let l34 = i32::from(*base.add(48+34*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                                                            match l34 {
                                                                                                                                                              0 => (),
                                                                                                                                                              _ => {
                                                                                                                                                                let l35 = *base.add(48+35*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                                                let l36 = *base.add(48+36*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                                _rt::cabi_dealloc(l35, l36, 1);
                                                                                                                                                              },
                                                                                                                                                            }
                                                                                                                                                          },
                                                                                                                                                        }
                                                                                                                                                        let l37 = i32::from(*base.add(48+37*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                                                        match l37 {
                                                                                                                                                          0 => (),
                                                                                                                                                          _ => {
                                                                                                                                                            let l38 = *base.add(48+38*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                                            let l39 = *base.add(48+39*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                            _rt::cabi_dealloc(l38, l39, 1);
                                                                                                                                                            let l40 = i32::from(*base.add(64+41*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                                                            match l40 {
                                                                                                                                                              0 => (),
                                                                                                                                                              _ => {
                                                                                                                                                                let l41 = *base.add(64+42*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                                                let l42 = *base.add(64+43*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                                _rt::cabi_dealloc(l41, l42, 1);
                                                                                                                                                              },
                                                                                                                                                            }
                                                                                                                                                          },
                                                                                                                                                        }
                                                                                                                                                        let l43 = i32::from(*base.add(64+44*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                                                        match l43 {
                                                                                                                                                          0 => (),
                                                                                                                                                          _ => {
                                                                                                                                                            let l44 = *base.add(64+45*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                                            let l45 = *base.add(64+46*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                            _rt::cabi_dealloc(l44, l45, 1);
                                                                                                                                                            let l46 = i32::from(*base.add(80+48*::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                                                            match l46 {
                                                                                                                                                              0 => (),
                                                                                                                                                              _ => {
                                                                                                                                                                let l47 = *base.add(80+49*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                                                let l48 = *base.add(80+50*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                                _rt::cabi_dealloc(l47, l48, 1);
                                                                                                                                                              },
                                                                                                                                                            }
                                                                                                                                                          },
                                                                                                                                                        }
                                                                                                                                                      },
                                                                                                                                                    }
                                                                                                                                                    let l49 = *base.add(80+51*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                                    let l50 = *base.add(80+52*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                    let base53 = l49;
                                                                                                                                                    let len53 = l50;
                                                                                                                                                    for i in 0..len53 {
                                                                                                                                                      let base = base53.add(i * (2*::core::mem::size_of::<*const u8>()));
                                                                                                                                                      {
                                                                                                                                                        let l51 = *base.add(0).cast::<*mut u8>();
                                                                                                                                                        let l52 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                        _rt::cabi_dealloc(l51, l52, 1);
                                                                                                                                                      }
                                                                                                                                                    }
                                                                                                                                                    _rt::cabi_dealloc(base53, len53 * (2*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                                                                                                                                    let l54 = *base.add(80+53*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                                    let l55 = *base.add(80+54*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                    let base60 = l54;
                                                                                                                                                    let len60 = l55;
                                                                                                                                                    for i in 0..len60 {
                                                                                                                                                      let base = base60.add(i * (4*::core::mem::size_of::<*const u8>()));
                                                                                                                                                      {
                                                                                                                                                        let l56 = *base.add(0).cast::<*mut u8>();
                                                                                                                                                        let l57 = *base.add(::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                        _rt::cabi_dealloc(l56, l57, 1);
                                                                                                                                                        let l58 = *base.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                                        let l59 = *base.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                        _rt::cabi_dealloc(l58, l59, 1);
                                                                                                                                                      }
                                                                                                                                                    }
                                                                                                                                                    _rt::cabi_dealloc(base60, len60 * (4*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                                                                                                                                  }
                                                                                                                                                }
                                                                                                                                                _rt::cabi_dealloc(base61, len61 * (80+55*::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>());
                                                                                                                                              },
                                                                                                                                              _ => {
                                                                                                                                                let l62 = i32::from(*arg0.add(::core::mem::size_of::<*const u8>()).cast::<u8>());
                                                                                                                                                match l62 {
                                                                                                                                                  0 => {
                                                                                                                                                    let l63 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                                    let l64 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                    _rt::cabi_dealloc(l63, l64, 1);
                                                                                                                                                  },
                                                                                                                                                  1 => {
                                                                                                                                                    let l65 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                                    let l66 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                    _rt::cabi_dealloc(l65, l66, 1);
                                                                                                                                                  },
                                                                                                                                                  2 => (),
                                                                                                                                                  3 => (),
                                                                                                                                                  4 => (),
                                                                                                                                                  5 => (),
                                                                                                                                                  6 => (),
                                                                                                                                                  7 => (),
                                                                                                                                                  8 => (),
                                                                                                                                                  9 => {
                                                                                                                                                    let l67 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                                    let l68 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                    _rt::cabi_dealloc(l67, l68, 1);
                                                                                                                                                  },
                                                                                                                                                  _ => {
                                                                                                                                                    let l69 = *arg0.add(2*::core::mem::size_of::<*const u8>()).cast::<*mut u8>();
                                                                                                                                                    let l70 = *arg0.add(3*::core::mem::size_of::<*const u8>()).cast::<usize>();
                                                                                                                                                    _rt::cabi_dealloc(l69, l70, 1);
                                                                                                                                                  },
                                                                                                                                                }
                                                                                                                                              },
                                                                                                                                            }
                                                                                                                                          } }
                                                                                                                                          pub trait Guest {
                                                                                                                                            #[allow(async_fn_in_trait)]
                                                                                                                                            fn get_home(ctx: RequestContext,) -> Result<_rt::Vec::<HomeSection>,PluginError>;
                                                                                                                                            #[allow(async_fn_in_trait)]
                                                                                                                                            fn get_category(ctx: RequestContext,id: _rt::String,page: PageCursor,) -> Result<PagedResult,PluginError>;
                                                                                                                                            #[allow(async_fn_in_trait)]
                                                                                                                                            fn search(ctx: RequestContext,query: _rt::String,filters: SearchFilters,) -> Result<PagedResult,PluginError>;
                                                                                                                                            #[allow(async_fn_in_trait)]
                                                                                                                                            fn get_info(ctx: RequestContext,id: _rt::String,) -> Result<MediaInfo,PluginError>;
                                                                                                                                            #[allow(async_fn_in_trait)]
                                                                                                                                            fn get_servers(ctx: RequestContext,id: _rt::String,) -> Result<_rt::Vec::<Server>,PluginError>;
                                                                                                                                            #[allow(async_fn_in_trait)]
                                                                                                                                            fn resolve_stream(ctx: RequestContext,server: Server,) -> Result<StreamSource,PluginError>;
                                                                                                                                            #[allow(async_fn_in_trait)]
                                                                                                                                            fn search_subtitles(ctx: RequestContext,query: SubtitleQuery,) -> Result<_rt::Vec::<SubtitleEntry>,PluginError>;
                                                                                                                                            #[allow(async_fn_in_trait)]
                                                                                                                                            fn download_subtitle(ctx: RequestContext,id: _rt::String,) -> Result<SubtitleFile,PluginError>;
                                                                                                                                            #[allow(async_fn_in_trait)]
                                                                                                                                            fn get_articles(ctx: RequestContext,) -> Result<_rt::Vec::<ArticleSection>,PluginError>;
                                                                                                                                            #[allow(async_fn_in_trait)]
                                                                                                                                            fn search_articles(ctx: RequestContext,query: _rt::String,) -> Result<_rt::Vec::<Article>,PluginError>;
                                                                                                                                          }
                                                                                                                                          #[doc(hidden)]

                                                                                                                                          macro_rules! __export_api_cabi{
                                                                                                                                            ($ty:ident with_types_in $($path_to_types:tt)*) => (const _: () = {

                                                                                                                                              #[unsafe(export_name = "api#get-home")]
                                                                                                                                              unsafe extern "C" fn export_get_home(arg0: *mut u8,arg1: usize,arg2: i32,arg3: *mut u8,arg4: usize,arg5: i32,arg6: *mut u8,arg7: usize,arg8: i32,arg9: *mut u8,arg10: usize,) -> *mut u8 {
                                                                                                                                                unsafe { $($path_to_types)*::_export_get_home_cabi::<$ty>(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) }
                                                                                                                                              }
                                                                                                                                              #[unsafe(export_name = "cabi_post_api#get-home")]
                                                                                                                                              unsafe extern "C" fn _post_return_get_home(arg0: *mut u8,) {
                                                                                                                                                unsafe { $($path_to_types)*::__post_return_get_home::<$ty>(arg0) }
                                                                                                                                              }
                                                                                                                                              #[unsafe(export_name = "api#get-category")]
                                                                                                                                              unsafe extern "C" fn export_get_category(arg0: *mut u8,) -> *mut u8 {
                                                                                                                                                unsafe { $($path_to_types)*::_export_get_category_cabi::<$ty>(arg0) }
                                                                                                                                              }
                                                                                                                                              #[unsafe(export_name = "cabi_post_api#get-category")]
                                                                                                                                              unsafe extern "C" fn _post_return_get_category(arg0: *mut u8,) {
                                                                                                                                                unsafe { $($path_to_types)*::__post_return_get_category::<$ty>(arg0) }
                                                                                                                                              }
                                                                                                                                              #[unsafe(export_name = "api#search")]
                                                                                                                                              unsafe extern "C" fn export_search(arg0: *mut u8,) -> *mut u8 {
                                                                                                                                                unsafe { $($path_to_types)*::_export_search_cabi::<$ty>(arg0) }
                                                                                                                                              }
                                                                                                                                              #[unsafe(export_name = "cabi_post_api#search")]
                                                                                                                                              unsafe extern "C" fn _post_return_search(arg0: *mut u8,) {
                                                                                                                                                unsafe { $($path_to_types)*::__post_return_search::<$ty>(arg0) }
                                                                                                                                              }
                                                                                                                                              #[unsafe(export_name = "api#get-info")]
                                                                                                                                              unsafe extern "C" fn export_get_info(arg0: *mut u8,arg1: usize,arg2: i32,arg3: *mut u8,arg4: usize,arg5: i32,arg6: *mut u8,arg7: usize,arg8: i32,arg9: *mut u8,arg10: usize,arg11: *mut u8,arg12: usize,) -> *mut u8 {
                                                                                                                                                unsafe { $($path_to_types)*::_export_get_info_cabi::<$ty>(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12) }
                                                                                                                                              }
                                                                                                                                              #[unsafe(export_name = "cabi_post_api#get-info")]
                                                                                                                                              unsafe extern "C" fn _post_return_get_info(arg0: *mut u8,) {
                                                                                                                                                unsafe { $($path_to_types)*::__post_return_get_info::<$ty>(arg0) }
                                                                                                                                              }
                                                                                                                                              #[unsafe(export_name = "api#get-servers")]
                                                                                                                                              unsafe extern "C" fn export_get_servers(arg0: *mut u8,arg1: usize,arg2: i32,arg3: *mut u8,arg4: usize,arg5: i32,arg6: *mut u8,arg7: usize,arg8: i32,arg9: *mut u8,arg10: usize,arg11: *mut u8,arg12: usize,) -> *mut u8 {
                                                                                                                                                unsafe { $($path_to_types)*::_export_get_servers_cabi::<$ty>(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12) }
                                                                                                                                              }
                                                                                                                                              #[unsafe(export_name = "cabi_post_api#get-servers")]
                                                                                                                                              unsafe extern "C" fn _post_return_get_servers(arg0: *mut u8,) {
                                                                                                                                                unsafe { $($path_to_types)*::__post_return_get_servers::<$ty>(arg0) }
                                                                                                                                              }
                                                                                                                                              #[unsafe(export_name = "api#resolve-stream")]
                                                                                                                                              unsafe extern "C" fn export_resolve_stream(arg0: *mut u8,) -> *mut u8 {
                                                                                                                                                unsafe { $($path_to_types)*::_export_resolve_stream_cabi::<$ty>(arg0) }
                                                                                                                                              }
                                                                                                                                              #[unsafe(export_name = "cabi_post_api#resolve-stream")]
                                                                                                                                              unsafe extern "C" fn _post_return_resolve_stream(arg0: *mut u8,) {
                                                                                                                                                unsafe { $($path_to_types)*::__post_return_resolve_stream::<$ty>(arg0) }
                                                                                                                                              }
                                                                                                                                              #[unsafe(export_name = "api#search-subtitles")]
                                                                                                                                              unsafe extern "C" fn export_search_subtitles(arg0: *mut u8,) -> *mut u8 {
                                                                                                                                                unsafe { $($path_to_types)*::_export_search_subtitles_cabi::<$ty>(arg0) }
                                                                                                                                              }
                                                                                                                                              #[unsafe(export_name = "cabi_post_api#search-subtitles")]
                                                                                                                                              unsafe extern "C" fn _post_return_search_subtitles(arg0: *mut u8,) {
                                                                                                                                                unsafe { $($path_to_types)*::__post_return_search_subtitles::<$ty>(arg0) }
                                                                                                                                              }
                                                                                                                                              #[unsafe(export_name = "api#download-subtitle")]
                                                                                                                                              unsafe extern "C" fn export_download_subtitle(arg0: *mut u8,arg1: usize,arg2: i32,arg3: *mut u8,arg4: usize,arg5: i32,arg6: *mut u8,arg7: usize,arg8: i32,arg9: *mut u8,arg10: usize,arg11: *mut u8,arg12: usize,) -> *mut u8 {
                                                                                                                                                unsafe { $($path_to_types)*::_export_download_subtitle_cabi::<$ty>(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12) }
                                                                                                                                              }
                                                                                                                                              #[unsafe(export_name = "cabi_post_api#download-subtitle")]
                                                                                                                                              unsafe extern "C" fn _post_return_download_subtitle(arg0: *mut u8,) {
                                                                                                                                                unsafe { $($path_to_types)*::__post_return_download_subtitle::<$ty>(arg0) }
                                                                                                                                              }
                                                                                                                                              #[unsafe(export_name = "api#get-articles")]
                                                                                                                                              unsafe extern "C" fn export_get_articles(arg0: *mut u8,arg1: usize,arg2: i32,arg3: *mut u8,arg4: usize,arg5: i32,arg6: *mut u8,arg7: usize,arg8: i32,arg9: *mut u8,arg10: usize,) -> *mut u8 {
                                                                                                                                                unsafe { $($path_to_types)*::_export_get_articles_cabi::<$ty>(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) }
                                                                                                                                              }
                                                                                                                                              #[unsafe(export_name = "cabi_post_api#get-articles")]
                                                                                                                                              unsafe extern "C" fn _post_return_get_articles(arg0: *mut u8,) {
                                                                                                                                                unsafe { $($path_to_types)*::__post_return_get_articles::<$ty>(arg0) }
                                                                                                                                              }
                                                                                                                                              #[unsafe(export_name = "api#search-articles")]
                                                                                                                                              unsafe extern "C" fn export_search_articles(arg0: *mut u8,arg1: usize,arg2: i32,arg3: *mut u8,arg4: usize,arg5: i32,arg6: *mut u8,arg7: usize,arg8: i32,arg9: *mut u8,arg10: usize,arg11: *mut u8,arg12: usize,) -> *mut u8 {
                                                                                                                                                unsafe { $($path_to_types)*::_export_search_articles_cabi::<$ty>(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12) }
                                                                                                                                              }
                                                                                                                                              #[unsafe(export_name = "cabi_post_api#search-articles")]
                                                                                                                                              unsafe extern "C" fn _post_return_search_articles(arg0: *mut u8,) {
                                                                                                                                                unsafe { $($path_to_types)*::__post_return_search_articles::<$ty>(arg0) }
                                                                                                                                              }
                                                                                                                                            };);
                                                                                                                                          }
                                                                                                                                          #[doc(hidden)]
                                                                                                                                          pub(crate) use __export_api_cabi;

                                                                                                                                          #[repr(align(8))]
                                                                                                                                          struct _RetArea([::core::mem::MaybeUninit::<u8>; 136+84*::core::mem::size_of::<*const u8>()]);
                                                                                                                                          static mut _RET_AREA: _RetArea = _RetArea([::core::mem::MaybeUninit::uninit(); 136+84*::core::mem::size_of::<*const u8>()]);

                                                                                                                                        }

                                                                                                                                      }
                                                                                                                                      mod _rt {
                                                                                                                                        #![allow(dead_code, unused_imports, clippy::all)]
                                                                                                                                        pub use alloc_crate::string::String;
                                                                                                                                        pub use alloc_crate::vec::Vec;
                                                                                                                                        pub use alloc_crate::alloc;

                                                                                                                                        pub fn as_i32<T: AsI32>(t: T) -> i32 {
                                                                                                                                          t.as_i32()
                                                                                                                                        }

                                                                                                                                        pub trait AsI32 {
                                                                                                                                          fn as_i32(self) -> i32;
                                                                                                                                        }

                                                                                                                                        impl<'a, T: Copy + AsI32> AsI32 for &'a T {
                                                                                                                                          fn as_i32(self) -> i32 {
                                                                                                                                            (*self).as_i32()
                                                                                                                                          }
                                                                                                                                        }
                                                                                                                                        
                                                                                                                                        impl AsI32 for i32 {
                                                                                                                                          #[inline]
                                                                                                                                          fn as_i32(self) -> i32 {
                                                                                                                                            self as i32
                                                                                                                                          }
                                                                                                                                        }
                                                                                                                                        
                                                                                                                                        impl AsI32 for u32 {
                                                                                                                                          #[inline]
                                                                                                                                          fn as_i32(self) -> i32 {
                                                                                                                                            self as i32
                                                                                                                                          }
                                                                                                                                        }
                                                                                                                                        
                                                                                                                                        impl AsI32 for i16 {
                                                                                                                                          #[inline]
                                                                                                                                          fn as_i32(self) -> i32 {
                                                                                                                                            self as i32
                                                                                                                                          }
                                                                                                                                        }
                                                                                                                                        
                                                                                                                                        impl AsI32 for u16 {
                                                                                                                                          #[inline]
                                                                                                                                          fn as_i32(self) -> i32 {
                                                                                                                                            self as i32
                                                                                                                                          }
                                                                                                                                        }
                                                                                                                                        
                                                                                                                                        impl AsI32 for i8 {
                                                                                                                                          #[inline]
                                                                                                                                          fn as_i32(self) -> i32 {
                                                                                                                                            self as i32
                                                                                                                                          }
                                                                                                                                        }
                                                                                                                                        
                                                                                                                                        impl AsI32 for u8 {
                                                                                                                                          #[inline]
                                                                                                                                          fn as_i32(self) -> i32 {
                                                                                                                                            self as i32
                                                                                                                                          }
                                                                                                                                        }
                                                                                                                                        
                                                                                                                                        impl AsI32 for char {
                                                                                                                                          #[inline]
                                                                                                                                          fn as_i32(self) -> i32 {
                                                                                                                                            self as i32
                                                                                                                                          }
                                                                                                                                        }
                                                                                                                                        
                                                                                                                                        impl AsI32 for usize {
                                                                                                                                          #[inline]
                                                                                                                                          fn as_i32(self) -> i32 {
                                                                                                                                            self as i32
                                                                                                                                          }
                                                                                                                                        }
                                                                                                                                        
                                                                                                                                        pub fn as_i64<T: AsI64>(t: T) -> i64 {
                                                                                                                                          t.as_i64()
                                                                                                                                        }

                                                                                                                                        pub trait AsI64 {
                                                                                                                                          fn as_i64(self) -> i64;
                                                                                                                                        }

                                                                                                                                        impl<'a, T: Copy + AsI64> AsI64 for &'a T {
                                                                                                                                          fn as_i64(self) -> i64 {
                                                                                                                                            (*self).as_i64()
                                                                                                                                          }
                                                                                                                                        }
                                                                                                                                        
                                                                                                                                        impl AsI64 for i64 {
                                                                                                                                          #[inline]
                                                                                                                                          fn as_i64(self) -> i64 {
                                                                                                                                            self as i64
                                                                                                                                          }
                                                                                                                                        }
                                                                                                                                        
                                                                                                                                        impl AsI64 for u64 {
                                                                                                                                          #[inline]
                                                                                                                                          fn as_i64(self) -> i64 {
                                                                                                                                            self as i64
                                                                                                                                          }
                                                                                                                                        }
                                                                                                                                        pub unsafe fn string_lift(bytes: Vec<u8>) -> String {
                                                                                                                                          if cfg!(debug_assertions) {
                                                                                                                                            String::from_utf8(bytes).unwrap()
                                                                                                                                          } else {
                                                                                                                                            unsafe { String::from_utf8_unchecked(bytes) }
                                                                                                                                          }
                                                                                                                                        }
                                                                                                                                        pub unsafe fn cabi_dealloc(ptr: *mut u8, size: usize, align: usize) {
                                                                                                                                          if size == 0 {
                                                                                                                                            return;
                                                                                                                                          }
                                                                                                                                          unsafe {
                                                                                                                                            let layout = alloc::Layout::from_size_align_unchecked(size, align);
                                                                                                                                            alloc::dealloc(ptr, layout);
                                                                                                                                          }
                                                                                                                                        }
                                                                                                                                        pub unsafe fn bool_lift(val: u8) -> bool {
                                                                                                                                          if cfg!(debug_assertions) {
                                                                                                                                            match val {
                                                                                                                                              0 => false,
                                                                                                                                              1 => true,
                                                                                                                                              _ => panic!("invalid bool discriminant"),
                                                                                                                                            }
                                                                                                                                          } else {
                                                                                                                                            val != 0
                                                                                                                                          }
                                                                                                                                        }
                                                                                                                                        pub unsafe fn invalid_enum_discriminant<T>() -> T {
                                                                                                                                          if cfg!(debug_assertions) {
                                                                                                                                            panic!("invalid enum discriminant")
                                                                                                                                          } else {
                                                                                                                                            unsafe { core::hint::unreachable_unchecked() }
                                                                                                                                          }
                                                                                                                                        }
                                                                                                                                        
                                                                                                                                        #[cfg(target_arch = "wasm32")]
                                                                                                                                        pub fn run_ctors_once() {
                                                                                                                                          wit_bindgen::rt::run_ctors_once();
                                                                                                                                        }
                                                                                                                                        
                                                                                                                                        pub fn as_f64<T: AsF64>(t: T) -> f64 {
                                                                                                                                          t.as_f64()
                                                                                                                                        }

                                                                                                                                        pub trait AsF64 {
                                                                                                                                          fn as_f64(self) -> f64;
                                                                                                                                        }

                                                                                                                                        impl<'a, T: Copy + AsF64> AsF64 for &'a T {
                                                                                                                                          fn as_f64(self) -> f64 {
                                                                                                                                            (*self).as_f64()
                                                                                                                                          }
                                                                                                                                        }
                                                                                                                                        
                                                                                                                                        impl AsF64 for f64 {
                                                                                                                                          #[inline]
                                                                                                                                          fn as_f64(self) -> f64 {
                                                                                                                                            self as f64
                                                                                                                                          }
                                                                                                                                        }
                                                                                                                                        
                                                                                                                                        pub fn as_f32<T: AsF32>(t: T) -> f32 {
                                                                                                                                          t.as_f32()
                                                                                                                                        }

                                                                                                                                        pub trait AsF32 {
                                                                                                                                          fn as_f32(self) -> f32;
                                                                                                                                        }

                                                                                                                                        impl<'a, T: Copy + AsF32> AsF32 for &'a T {
                                                                                                                                          fn as_f32(self) -> f32 {
                                                                                                                                            (*self).as_f32()
                                                                                                                                          }
                                                                                                                                        }
                                                                                                                                        
                                                                                                                                        impl AsF32 for f32 {
                                                                                                                                          #[inline]
                                                                                                                                          fn as_f32(self) -> f32 {
                                                                                                                                            self as f32
                                                                                                                                          }
                                                                                                                                        }
                                                                                                                                        extern crate alloc as alloc_crate;
                                                                                                                                      }

                                                                                                                                      /// Generates `#[unsafe(no_mangle)]` functions to export the specified type as
                                                                                                                                      /// the root implementation of all generated traits.
                                                                                                                                      ///
                                                                                                                                      /// For more information see the documentation of `wit_bindgen::generate!`.
                                                                                                                                      ///
                                                                                                                                      /// ```rust
                                                                                                                                      /// # macro_rules! export{ ($($t:tt)*) => (); }
                                                                                                                                      /// # trait Guest {}
                                                                                                                                      /// struct MyType;
                                                                                                                                      ///
                                                                                                                                      /// impl Guest for MyType {
                                                                                                                                      ///     // ...
                                                                                                                                      /// }
                                                                                                                                      ///
                                                                                                                                      /// export!(MyType);
                                                                                                                                      /// ```
                                                                                                                                      #[allow(unused_macros)]
                                                                                                                                      #[doc(hidden)]

                                                                                                                                      macro_rules! __export_plugin_impl {
                                                                                                                                        ($ty:ident) => (self::export!($ty with_types_in self););
                                                                                                                                        ($ty:ident with_types_in $($path_to_types_root:tt)*) => (
                                                                                                                                        $($path_to_types_root)*::exports::api::__export_api_cabi!($ty with_types_in $($path_to_types_root)*::exports::api);
                                                                                                                                        )
                                                                                                                                      }
                                                                                                                                      #[doc(inline)]
                                                                                                                                      pub(crate) use __export_plugin_impl as export;

                                                                                                                                      #[cfg(target_arch = "wasm32")]
                                                                                                                                      #[unsafe(link_section = "component-type:wit-bindgen:0.57.1:bex:plugin@1.0.0:plugin:encoded world")]
                                                                                                                                      #[doc(hidden)]
                                                                                                                                      #[allow(clippy::octal_escapes)]
                                                                                                                                      pub static __WIT_BINDGEN_COMPONENT_TYPE: [u8; 4381] = *b"\
\0asm\x0d\0\x01\0\0\x19\x16wit-component-encoding\x04\0\x07\xa0!\x01A\x02\x01A\x1f\
\x01BS\x01ks\x01ps\x01r\x05\x0arequest-ids\x06locale\0\x06region\0\x09safe-mode\x7f\
\x05hints\x01\x04\0\x0frequest-context\x03\0\x02\x01r\x02\x03keys\x05values\x04\0\
\x04attr\x03\0\x04\x01m\x06\x08portrait\x09landscape\x06square\x06banner\x08circ\
ular\x07unknown\x04\0\x0cimage-layout\x03\0\x06\x01ky\x01r\x05\x03urls\x06layout\
\x07\x05width\x08\x06height\x08\x08blurhash\0\x04\0\x05image\x03\0\x09\x01k\x0a\x01\
r\x05\x03low\x0b\x06medium\x0b\x04high\x0b\x08backdrop\x0b\x04logo\x0b\x04\0\x09\
image-set\x03\0\x0c\x01r\x02\x06sources\x02ids\x04\0\x09linked-id\x03\0\x0e\x01m\
\x0b\x05movie\x06series\x05anime\x05short\x07special\x0bdocumentary\x05music\x07\
podcast\x04book\x04live\x07unknown\x04\0\x0amedia-kind\x03\0\x10\x01m\x06\x07unk\
nown\x08upcoming\x07ongoing\x09completed\x09cancelled\x06paused\x04\0\x06status\x03\
\0\x12\x01m\x05\x08carousel\x04grid\x0dvertical-list\x06banner\x07compact\x04\0\x0b\
card-layout\x03\0\x14\x01r\x02\x05token\0\x05limit\x08\x04\0\x0bpage-cursor\x03\0\
\x16\x01k\x11\x01k\x0d\x01k\x13\x01p\x0f\x01p\x05\x01r\x0e\x02ids\x05titles\x04k\
ind\x18\x06images\x19\x0eoriginal-title\0\x07tagline\0\x04year\0\x05score\x08\x06\
genres\x01\x06status\x1a\x0econtent-rating\0\x03url\0\x03ids\x1b\x05extra\x1c\x04\
\0\x0amedia-card\x03\0\x1d\x01r\x04\x02ids\x05titles\x08subtitle\0\x05image\x0b\x04\
\0\x0dcategory-link\x03\0\x1f\x01p\x1e\x01p\x20\x01r\x09\x02ids\x05titles\x08sub\
title\0\x05items!\x09next-page\0\x06layout\x15\x09show-rank\x7f\x0acategories\"\x05\
extra\x1c\x04\0\x0chome-section\x03\0#\x01r\x03\x05items!\x0acategories\"\x09nex\
t-page\0\x04\0\x0cpaged-result\x03\0%\x01r\x03\x04kind\x18\x04page\x17\x0afast-m\
atch\x7f\x04\0\x0esearch-filters\x03\0'\x01ku\x01r\x0b\x02ids\x05titles\x06numbe\
r)\x06season)\x06images\x19\x0bdescription\0\x08released\0\x05score\x08\x03url\0\
\x04tags\x01\x05extra\x1c\x04\0\x07episode\x03\0*\x01p+\x01r\x05\x02ids\x05title\
s\x06number)\x04year\x08\x08episodes,\x04\0\x06season\x03\0-\x01r\x05\x02ids\x04\
names\x05image\x19\x04role\0\x03url\0\x04\0\x06person\x03\0/\x01kw\x01p.\x01p0\x01\
r\x19\x02ids\x05titles\x04kind\x11\x06images\x19\x0eoriginal-title\0\x0bdescript\
ion\0\x05score\x08\x09scored-by1\x04year\0\x0crelease-date\0\x06genres\x01\x04ta\
gs\x01\x06status\x1a\x0econtent-rating\0\x07seasons2\x04cast3\x04crew3\x0fruntim\
e-minutes\x08\x0btrailer-url\0\x03ids\x1b\x06studio\0\x07country\0\x08language\0\
\x03url\0\x05extra\x1c\x04\0\x0amedia-info\x03\04\x01r\x04\x05widthy\x06heighty\x03\
hdr\x7f\x05labels\x04\0\x10video-resolution\x03\06\x01m\x04\x03hls\x04dash\x0bpr\
ogressive\x07unknown\x04\0\x0dstream-format\x03\08\x01r\x05\x0aresolution7\x03ur\
ls\x09mime-type\0\x07bitrate1\x06codecs\0\x04\0\x0bvideo-track\x03\0:\x01r\x04\x05\
labels\x03urls\x08language\0\x06format\0\x04\0\x0esubtitle-track\x03\0<\x01r\x05\
\x02ids\x05labels\x03urls\x08priority}\x05extra\x1c\x04\0\x06server\x03\0>\x01p;\
\x01p=\x01r\x08\x02ids\x05labels\x06format9\x0cmanifest-url\0\x06videos\xc0\0\x09\
subtitles\xc1\0\x07headers\x1c\x05extra\x1c\x04\0\x0dstream-source\x03\0B\x01kv\x01\
r\x09\x05title\0\x04year\x08\x06season\x08\x07episode\x08\x08language\0\x03fps\xc4\
\0\x09file-hash\0\x09file-size1\x0bidentifiers\x1b\x04\0\x0esubtitle-query\x03\0\
E\x01r\x0d\x02ids\x05titles\x08languages\x06formats\x03url\0\x07release\0\x03fps\
\xc4\0\x09downloads1\x05score\x08\x10hearing-impaired\x7f\x12machine-translated\x7f\
\x09file-hash\0\x05extra\x1c\x04\0\x0esubtitle-entry\x03\0G\x01p}\x01r\x02\x06fo\
rmats\x07content\xc9\0\x04\0\x0dsubtitle-file\x03\0J\x01r\x09\x02ids\x05titles\x07\
summary\0\x03urls\x09published\0\x06author\0\x09thumbnail\x19\x04tags\x01\x05ext\
ra\x1c\x04\0\x07article\x03\0L\x01p\xcd\0\x01r\x04\x02ids\x05titles\x05items\xce\
\0\x09next-page\0\x04\0\x0farticle-section\x03\0O\x01q\x0b\x07network\x01s\0\x05\
parse\x01s\0\x09not-found\0\0\x0cunauthorized\0\0\x09forbidden\0\0\x0crate-limit\
ed\x01\x08\0\x07timeout\0\0\x09cancelled\0\0\x0bunsupported\0\0\x0dinvalid-input\
\x01s\0\x08internal\x01s\0\x04\0\x0cplugin-error\x03\0Q\x03\0\x17bex:plugin/comm\
on@1.0.0\x05\0\x02\x03\0\0\x04attr\x02\x03\0\0\x0cplugin-error\x01B\x14\x02\x03\x02\
\x01\x01\x04\0\x04attr\x03\0\0\x02\x03\x02\x01\x02\x04\0\x0cplugin-error\x03\0\x02\
\x01m\x07\x03get\x04post\x03put\x06delete\x04head\x05patch\x07options\x04\0\x06m\
ethod\x03\0\x04\x01m\x04\x06normal\x08no-store\x0aonly-cache\x0dforce-refresh\x04\
\0\x0acache-mode\x03\0\x06\x01p\x01\x01p}\x01k\x09\x01ky\x01kw\x01r\x08\x06metho\
d\x05\x03urls\x07headers\x08\x04body\x0a\x0atimeout-ms\x0b\x10follow-redirects\x7f\
\x0acache-mode\x07\x09max-bytes\x0c\x04\0\x07request\x03\0\x0d\x01r\x05\x06statu\
s{\x07headers\x08\x04body\x09\x06cached\x7f\x09final-urls\x04\0\x08response\x03\0\
\x0f\x01j\x01\x10\x01\x03\x01@\x01\x03req\x0e\0\x11\x04\0\x0csend-request\x01\x12\
\x03\0\x15bex:plugin/http@1.0.0\x05\x03\x01B\x0e\x02\x03\x02\x01\x01\x04\0\x04at\
tr\x03\0\0\x01p}\x01ky\x01@\x03\x03keys\x05value\x02\x0bttl-seconds\x03\0\x7f\x04\
\0\x03set\x01\x04\x01k\x02\x01@\x01\x03keys\0\x05\x04\0\x03get\x01\x06\x01@\x01\x03\
keys\0\x7f\x04\0\x06remove\x01\x07\x01ps\x01@\x01\x06prefixs\0\x08\x04\0\x04keys\
\x01\x09\x03\0\x13bex:plugin/kv@1.0.0\x05\x04\x01B\x03\x01ks\x01@\x01\x03keys\0\0\
\x04\0\x03get\x01\x01\x03\0\x18bex:plugin/secrets@1.0.0\x05\x05\x01B\x07\x02\x03\
\x02\x01\x01\x04\0\x04attr\x03\0\0\x01m\x05\x05trace\x05debug\x04info\x04warn\x05\
error\x04\0\x05level\x03\0\x02\x01p\x01\x01@\x03\x05level\x03\x03msgs\x06fields\x04\
\x01\0\x04\0\x05write\x01\x05\x03\0\x14bex:plugin/log@1.0.0\x05\x06\x01B\x03\x01\
@\0\0w\x04\0\x06now-ms\x01\0\x04\0\x09monotonic\x01\0\x03\0\x16bex:plugin/clock@\
1.0.0\x05\x07\x01B\x03\x01p}\x01@\x01\x03leny\0\0\x04\0\x05bytes\x01\x01\x03\0\x14\
bex:plugin/rng@1.0.0\x05\x08\x02\x03\0\0\x0frequest-context\x02\x03\0\0\x0bpage-\
cursor\x02\x03\0\0\x0cpaged-result\x02\x03\0\0\x0esearch-filters\x02\x03\0\0\x0c\
home-section\x02\x03\0\0\x0amedia-info\x02\x03\0\0\x06server\x02\x03\0\0\x0dstre\
am-source\x02\x03\0\0\x0esubtitle-query\x02\x03\0\0\x0esubtitle-entry\x02\x03\0\0\
\x0dsubtitle-file\x02\x03\0\0\x0farticle-section\x02\x03\0\0\x07article\x01B>\x02\
\x03\x02\x01\x09\x04\0\x0frequest-context\x03\0\0\x02\x03\x02\x01\x0a\x04\0\x0bp\
age-cursor\x03\0\x02\x02\x03\x02\x01\x0b\x04\0\x0cpaged-result\x03\0\x04\x02\x03\
\x02\x01\x0c\x04\0\x0esearch-filters\x03\0\x06\x02\x03\x02\x01\x0d\x04\0\x0chome\
-section\x03\0\x08\x02\x03\x02\x01\x0e\x04\0\x0amedia-info\x03\0\x0a\x02\x03\x02\
\x01\x0f\x04\0\x06server\x03\0\x0c\x02\x03\x02\x01\x10\x04\0\x0dstream-source\x03\
\0\x0e\x02\x03\x02\x01\x11\x04\0\x0esubtitle-query\x03\0\x10\x02\x03\x02\x01\x12\
\x04\0\x0esubtitle-entry\x03\0\x12\x02\x03\x02\x01\x13\x04\0\x0dsubtitle-file\x03\
\0\x14\x02\x03\x02\x01\x14\x04\0\x0farticle-section\x03\0\x16\x02\x03\x02\x01\x15\
\x04\0\x07article\x03\0\x18\x02\x03\x02\x01\x02\x04\0\x0cplugin-error\x03\0\x1a\x01\
p\x09\x01j\x01\x1c\x01\x1b\x01@\x01\x03ctx\x01\0\x1d\x04\0\x08get-home\x01\x1e\x01\
j\x01\x05\x01\x1b\x01@\x03\x03ctx\x01\x02ids\x04page\x03\0\x1f\x04\0\x0cget-cate\
gory\x01\x20\x01@\x03\x03ctx\x01\x05querys\x07filters\x07\0\x1f\x04\0\x06search\x01\
!\x01j\x01\x0b\x01\x1b\x01@\x02\x03ctx\x01\x02ids\0\"\x04\0\x08get-info\x01#\x01\
p\x0d\x01j\x01$\x01\x1b\x01@\x02\x03ctx\x01\x02ids\0%\x04\0\x0bget-servers\x01&\x01\
j\x01\x0f\x01\x1b\x01@\x02\x03ctx\x01\x06server\x0d\0'\x04\0\x0eresolve-stream\x01\
(\x01p\x13\x01j\x01)\x01\x1b\x01@\x02\x03ctx\x01\x05query\x11\0*\x04\0\x10search\
-subtitles\x01+\x01j\x01\x15\x01\x1b\x01@\x02\x03ctx\x01\x02ids\0,\x04\0\x11down\
load-subtitle\x01-\x01p\x17\x01j\x01.\x01\x1b\x01@\x01\x03ctx\x01\0/\x04\0\x0cge\
t-articles\x010\x01p\x19\x01j\x011\x01\x1b\x01@\x02\x03ctx\x01\x05querys\02\x04\0\
\x0fsearch-articles\x013\x04\0\x03api\x05\x16\x04\0\x17bex:plugin/plugin@1.0.0\x04\
\0\x0b\x0c\x01\0\x06plugin\x03\0\0\0G\x09producers\x01\x0cprocessed-by\x02\x0dwi\
t-component\x070.247.0\x10wit-bindgen-rust\x060.57.1";

                                                                                                                                      #[inline(never)]
                                                                                                                                      #[doc(hidden)]
                                                                                                                                      pub fn __link_custom_section_describing_imports() {
                                                                                                                                        wit_bindgen::rt::maybe_link_cabi_realloc();
                                                                                                                                      }