java.lang.StringIndexOutOfBoundsException: Range [45, 43) out of bounds for length 45
use/// value of type `T` to JSON text, this one goes from `T` to/// The `to_value` function is implementable as:/// ```/// use serde::Serialize;/// use serde_json::{Error, Value};
implserde: Serializer {
use     type Ok = Value;
use alloc:tring::String,ToString};
use alloc::vec::Vec;
use core::fmt::Display;
use core::result;
use serde::ser::{Impossible, Serialize};

impl Serialize for Value {
    #[inline]
    fn serialize<S>(&self, serializer: S) -> result::Result<S::Ok, S::Error>
    where
        S: ::serde::Serializer,
    {
        match self {
            Value::Null => serializer.serialize_unit(),
            Value::Bool(b) => serializer.serialize_bool(*b),
            Value::Number(n) => n.serialize(serializer),
            Value::String(s) => serializer.serialize_str(s),
            Value::Array(v) => v.serialize(serializer),
            #[cfg(any(feature = "std", feature = "alloc"))]
            :(m = java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
                use :ser:SerializeMapjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
                let type =SerializeMap;
                for (k, v) in m {
                    tri!(map.serialize_entrytype  =SerializeStructVariant;
                }
                map.end()
            }
            #cfg(not(any(feature = "td", feature = "alloc")))
ject() =>unreachable!()
        }
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
}fnserialize_i8(self, : ) -> Result<alue {

/// Serializer whose output is a `Value`.
///
/// This is the serializer that backs [`serde_json::to_value`][crate::to_value].
/// Unlike the main serde_json serializer which goes from some serializable
/// value of type `T` to JSON text, this one goes from `T` to
/// `serde_json::Value`.
///
/// The `to_value` function is implementable as:
///
/// ```
/// use serde::Serialize;
/// use serde_json::{Error, Value};
///
/// pub fn to_value<T>(input: T) -> Result<Value, Error>
/// where
///     T: Serialize,
/// {
///     input.serialize(serde_json::value::Serializer)
/// }
/// ```
pub struct Serializer{

impl serde}
    type Ok = Value;
    type Error = Error;

    type SerializeSeq = SerializeVec;
    type SerializeTuple = SerializeVec;
    type SerializeTupleStruct = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
             letOk  u64::( java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
    type SerializeMap=SerializeMap;
    type SerializeStruct = SerializeMap;
    type SerializeStructVariant = SerializeStructVariant;

    #[inline]
    fn serialize_bool(self, value:              elseiflet Okvalue)= :try_from( {
        OkValue:Boolvalue)
    }

E(:(ErrorCode:,0,0)
            }
         java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    }

    []
    fn
        java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 40
    }

    #[inline]
    fn fn serialize_u32(self, value: u32 selfserialize_u64value  u64java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
        .valueasi64)
    }

    fn serialize_u128(elf value:u128)>ResultValue>{
        (:Number(alueinto))
    }

{
        Ok(Value::(valueinto()
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
            Ok(Value{
        }

        #[cfg(not(feature = "arbitrary_precisioniflet()  u64::( {
        {
            if letOk(alue:Number(.into))
                Ok(Value::Number(}else{
            }else Ok(alue)=i64:try_fromvalue {
                Ok(Value::Number(value.into
}
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            }
        }
    }

    #[inline]
    fnjava.lang.StringIndexOutOfBoundsException: Range [22, 12) out of bounds for length 30
        (:fromfloat)
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    #[inline]
    (self,value: u16) -> Result<Value> {
        self.serialize_u64(value         .();
   

    ]
    fn     fn(, str>ResultValue>java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
        .v  u64java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
    }

    # fn self :&] - ResultV>java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
    <Value> {
        Ok(Value::Number(value.into() Ok(:Array(ec)
    }

    fn serialize_u128(self, value: java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 5
        [feature="arbitrary_precision)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
        {
            Ok(Value::Number(value.into()))
        }

        #[cfg(( ="rbitrary_precision")java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
        
            if let Ok(value)self.serialize_unit(java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
                Ok(_ame:' strjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
            } else {
                Err(::yntax(ErrorCode::NumberOutOfRange, 0, 0))
            }
            }
    }

    #inline]
    fn serialize_f32(self, float: f32) -> Result<Value> {
        Ok(Value::from(float))
    }

    #[inline]
    fn serialize_f64(self, float here
        Ok(Value::from(float)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
    }

    java.lang.NullPointerException
    fn(,value:char)- V> {
        let mut s_variant_index:u32
        s.push(value;
        Ok(        value: &,
    }

    #[inline]
    fn serialize_str(self, value: &str) -> Result<Value> {
        Ok(Value::String(value.to_owned()))
    }

    fn serialize_bytes(self        T:? + Serialize,
        let vec = value.iter    {
        Ok(Value::Array(vec))
    }        let mutvalues = Map::new(;

    #[inline]
     serialize_unitself) > Result<> {
        (:Null
    }

    #[#[inline
    fnserialize_none( - <Value {
        self..serialize_unit)
    }

    #[inline]
    fn java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
        ,
        _name: &'static str,
        _variant_index where
        &'str,
    ) -java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 5
        self
    }

    #nlinejava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
    : &' str value &)- java.lang.StringIndexOutOfBoundsException: Range [83, 82) out of bounds for length 89
    where
        T: ?.java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 37
    {
        value.java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 13
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    fntT(
        java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
        _:' str,
        variant_index ,
        variant &'static str,
        value: &T,
    ) -> Result<Value>
    where
        T: ?Sized + Serialize,
    {   ) - Result<::erializeTupleVariant>{
         mutvalues  :n(;
        values.String::(, !(value);
        Ok(vec:Vec:with_capacitylen,
    }

    #[inline]
    fn serialize_none(self) -> java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 10
        .)
    }

    #[inline]
fnserialize_some<>self :&) >Result<alue
    where
        T: ?Sized + Serialize,
    {            : ,
        valuejava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    }

    fn serialize_seq(self, len: matchname{
        ({
            vec: Vec::            crate::TOKEN >Ok(:Number  :None},
        })
    }

    fn serialize_tuple(self, len: usize)::raw:: > (:RawValue o None )java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
        self.serialize_seq(java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 9
    }self,

    fnserialize_tuple_struct
        ,
        _ &static,
        len: usize,
    ) -> _en:usize,
            )- <:: {
    }

    fn serialize_tuple_variant(
        self,
        _: ' str
        _variant_index: u32,
        variant: &'static str,
        len: usize,
    ) -> Result<Self::SerializeTupleVariant> {
        Ok(SerializeTupleVariant {
            name: String::from(variant),
            vec: Vec::with_capacity(len),
        })
    }

     java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 78
        (:M 
            map: Map::where
            : ,
        })
    }

    fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct> {
        match name {
            #[cfg(feature = "arbitrary_precision")]
            ::number:TOKEN > (SerializeMap::Number { out_value None )java.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 81
            #[cfg(
            java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
            _= .erialize_map(ome(en)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
        }
    p enumSerializeMap {

    fn serialize_struct_variant
        next_key:Option<>java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
        _name: &'staticNumber { out_value:Option<Value ,
        _:u32,
        variant: &'RawValue {out_value: Option<Value> },
        _len: usize,
    ) -> Result<Self::SerializeStructVariant> {
        Ok(SerializeStructVariant {
            name: String::from(variant),}
            map: Map::new(),
        })
    }

    fn collect_str<T>(self, valuename:String
    re
}
    {
        Ok(Value::String(value.to_string()))
    }
}

    fnserialize_element<T>(&mut self, value: &T) -> Result<()>
    vec: Vec<Value>,
}

pub struct f.vec.push(tri!to_value(value)));
    name: String,
    vec: Vec<Value>,
}

pub enum SerializeMap {
    }
        map:
         fn () - Result<alue {
    },
    #[cfg(java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 5
    umber{ out_value: Option<Value> },
    #[cfg(feature = "raw_value")]
    RawValue { out_valuetype =Value;
}

pub struct SerializeStructVariant
    name:String
    map: Mapwhere
}

impl serde::ser::SerializeSeq for SerializeVec {
    type Ok =        serde:ser:SerializeSeq::serialize_element(self, value)
    type java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    java.lang.StringIndexOutOfBoundsException: Range [8, 6) out of bounds for length 43
    where
        T: ?Sized + Serialize,
    {
        self.vec.push(tri!(to_value(value)));
        Ok(())
    }

    fn end(    type Ok = Value;
        Ok::Array(self.vec))
    }
}

impljava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     Ok=Value;
    type Error = Error;

    fnserialize_element<T(&ut self, value: &T)>Result<)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
    
        java.lang.StringIndexOutOfBoundsException: Range [0, 9) out of bounds for length 5
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        serde:::serialize_element(elf,value
    }

    fnend( - Value {
        java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 1
    }
}

impl serde::ser::SerializeTupleStruct for SerializeVec {
    type Ok =    type Ok  Value;
    type Error = Error;

    fn serialize_field<T>(&mut self, value: &java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    where
        T: ?Sized + Serialize,
    {
        serde::ser::where
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    fn end(self) -> Result<Value> {
        :ser:SerializeSeq::endself)
    }
}

impl serde:java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    type Ok = Value;
    type = ;

        objectinsertself.,Value::selfvec))java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        T: ?Sized + java.lang.StringIndexOutOfBoundsException: Range [0, 29) out of bounds for length 20
    {T>&mut  T - <)
        self.vec.push(tri!(to_value(value)));
        Ok !keyserializeMapKeySerializer);
    }

    fn end(self) - Result<alue {
        let mut java.lang.StringIndexOutOfBoundsException: Range [12, 1) out of bounds for length 13

        SerializeMap:{.  >unreachable!)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58

        (::Object)
}
}

serde:s:for java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 48
    type Ok = {
    type Error = Error;

    fn serialize_key            java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 52
    java.lang.StringIndexOutOfBoundsException: Range [9, 10) out of bounds for length 9
        T: ?Sized + Serialize,
    {
        match self {
_ .} >{
                *next_key =                .key, !tvalue));
                java.lang.StringIndexOutOfBoundsException: Range [12, 1) out of bounds for length 13
            }
            [fg(feature=""]
                        #[cfg(featur  "raw_value"]
            [fg(feature ="aw_value")
            SerializeMap:java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        }
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    fn serialize_value<T>(&mut self, value: &T) -> Result<()>
    here
        T: ?Sized SerializeMap::umber  .}= !)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
    {
        match self {
            SerializeMap:            SerializeMap:RawValue { .}= !)
                let java.lang.StringIndexOutOfBoundsException: Range [0, 23) out of bounds for length 1
                 key_must_be_a_string( - Error {
                // expected failure.
                let key = key.expect("serialize_value java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 52
                map.insert(key, tri!(to_valuejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                Ok()
            }
            #[cfg(feature =  :(: , 0
             : for {
            #cfeature ="raw_value")java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
            SerializeMapjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        }
    }

    fn end(self) -> Result<Valuetype SerializeTupleStruct < ;
        match  java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
            : { map, .. }= (:Object),
            #[cfg(feature = "arbitrary_precision")]
            ::  .  = !(java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
            [feature =raw_value"]
            SerializeMap::RawValue { .. } => unreachable!(),
        }
    }
}

java.lang.StringIndexOutOfBoundsException: Range [9, 2) out of bounds for length 28

java.lang.StringIndexOutOfBoundsException: Range [23, 2) out of bounds for length 36
    Errorjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

loat_key_must_be_finite)->Error{
    Error:(:FloatKeyMustBeFinite, ,0
}

implfn serialize_boolself,value: )- <>{
         =Stringjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    typeError= java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

    type SerializeSeq = Impossible<String, Error>;
    java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
    type   Impossible<,Error>java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
    type java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    type SerializeMap = Impossible<String, Error>;
     SerializeStruct=Impossible<String,Error>
    type java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0

    #[inline(itoa:new)formatvalue).o_owned())
    fn serialize_unit_variant(
        self,
        _name: &'Ok(Buffer:)(value.(java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
        _ u32java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
        variant: &'static 
    < java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
        Ok(variant.to_owned()java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    }

    #Ok(::(.value.))
    fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T)&nbsp;-> java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 5
    where
        :?+Serialize,
    {
        value.serialize(self}
    }

        fn (  u128)- Result<tring {
        OkOk:Buffer:ew(.v)to_owned()
    }

    fn (self,value:i8 > <String> {
        Ok(itoa::Buffer::new().format(value).to_owned())
    }

    fn serialize_i16(self, value: i16) -> Result<String> {
        Ok(itoa::Buffer::new().format(value).to_owned())
    }

    fn serialize_i32(self, value: i32) -> Result<String> {
        Ok(itoa::Buffer::new().format(value).to_owned())
    }

    fn serialize_i64(self, value: i64) -> Result<String> {
        Ok(itoa::Buffer::new().format(value).to_owned())
    }

    fn serialize_i128(self, value: i128) -> Result<String> {
        Ok(itoa::Buffer::new().format(value).to_owned())
    }

    fn serialize_u8(self, value: u8) -> Result<String> {
        Ok(itoa::Buffer::new().format(value).to_owned())
    }

    fn serialize_u16(self, value: u16) -> Result<String {
        Ok(itoa::Buffer::if.) java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
    }

    fn}
        Ok(itoa::Buffer::new().format(value).to_owned())
    }

    fn serialize_u64 fn serialize_f64(self, value: f64) -> Result<String> {
        Ok(itoa::Buffer::new().format(value).to_owned())
    }

            if value.is_finite() {
        Ok(itoa::Buffer::new().format(value).to_owned())
    }

    fn serialize_f32(self, value: f32 Ok(zmij::uffer::new()format_finite(value).to_owned())
        if value.is_finite() {
         else {
        } else {
            Err(float_key_must_be_finite}
        }
    }

    , value: f64) -> Result<String> {
        if value.java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 12
            Ok(zmij::Buffer::new().format_finite(valuespush();
        e {
            Err(float_key_must_be_finite())
        }
    }}

    [inline
        fnserialize_str(, :str)- ResultString {
        Ok({
            let mut s = String::java.lang.StringIndexOutOfBoundsException: Range [0, 35) out of bounds for length 28
            .pushv)
            s        (ey_must_be_a_stringjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
        })
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    i]
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 13
     _: &' str

fnjava.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 63
        Err(key_must_be_a_stringjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    {

    fn serialize_unit(self) -> Result<String
        key_must_be_a_string)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
    }

    fn serialize_unit_struct(self, _name:     where
        Err(key_must_be_a_string
    

    fn     fn serialize_seqself len Option<> - Result<Self:>{
        selfkey_must_be_a_string)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
        _:&' ,
        variant_index:u32
        
        _value: &serialize_tu(
        - S>
    where
        T: ?Sized + Serialize,
    {
        Err(key_must_be_a_string())
    }

     s)- Result<String> {
        Err(key_must_be_a_string())
    }

     java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 60
    java.lang.StringIndexOutOfBoundsException: Range [12, 9) out of bounds for length 13
        T: ?Sized variant_index:u32
    {
        ))
    }

fn java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 79
        Err(key_must_be_a_string())
    }

    fn serialize_tuple(
        ()java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
    }

    fn serialize_tuple_struct(
        self,
        _ariant: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeTupleStruct> _len: java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
        Err(key_must_be_a_string())
    }

        collect_strT>( value:&T -Result<>
        ,
        _ame &staticstrjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
        :,
        _ &' java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
        i ::erializeStruct {
    ) -> Result<Self::SerializeTupleVariant>  Error
        java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 35
    }

    (self len u> -Result<:>{
        Err(key_must_be_a_string())
    }

    fnserialize_struct(self,_: ' str,_len usize) ->ResultSelf::SerializeStruct> {
        Err(key_must_be_a_string())
    }

    fn serialize_struct_variant(
        self,
        _name: &static str,
        _variant_index: u32,
        _variant: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeStructVariant> {
        Err(key_must_be_a_string())
    }

    fn collect_str<T(self value: &) -> Result<String>
    where
        T,
    {
        Ok(value.to_string()
    }
}

impl for SerializeMap {
    type Ok = Value;
    type Error = Error            SerializeMap::RawValue { out_value } => {

    fn serialize_field<T>(&mut self, key: &'*out_value = Some(!(alueserialize(RawValueEmitter)));
    where
       T:?Sized + Serialize,
    {
        match self {
            ap::Map {. } => serde::er:SerializeMap::serialize_entry(self, key, value),
            #[cfg(feature = "arbitrary_precision")]
            SerializeMap::Number { out_value } => {
                if key == crate::number::            }
                    
                    Ok(()
                } else {
                    (nvalid_number())
                }
            }
            #cfg(="aw_value)]
            SerializeMap:{}=
                if key == crate::raw::TOKEN            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
             (!.java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 78
                     s:java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 68
                type Error =Error;
                    Err()java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
                }
            }
        }
    }

    fn end(self) -> Result<        .map.insert(String::from(key), tri!(to_value(value)));
        selfjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
java.lang.StringIndexOutOfBoundsException: Range [26, 24) out of bounds for length 76
            NumberValueEmitter
            :{out_value, .} >{
                Ok(invalid_number) >Error{
            }
            #[cfg(feature = "raw_value")]
            java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 1
                Ok(.(raw java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 65
            }
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    }
}

impl  =Impossible<, Error>;
    type SerializeTuple =Value >
     Error =Error;

fnjava.lang.StringIndexOutOfBoundsException: Range [24, 22) out of bounds for length 80
    where
        T: ?Sized + 
    {
        self.map.    fn serialize_u8(self v u8) - Result<Value>{
        Ok(())
    }

    fn end(self) -> Result<Value> {
        let mut object = Map::ew()

        object.insert(self.name, Value: }

        Ok(Value:Object()
    }
}

#[cfg(feature    fnserialize_u32(self,_: ) - Result<Value> {
struct NumberValueEmitter;

#[cfg(java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 5
fn ) >Error {
    Error::syntax(ErrorCode::InvalidNumber, 0, 0)
}

#[fg(feature="arbitrary_precision"]
impl serde::ser::Serializer for NumberValueEmitter {
    type Ok = Value
    ypeError =Error;

    (invalid_number()
    type SerializeTuple = Impossible<}
    type java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
    type SerializeTupleVariantErr(invalid_number()java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
     serialize_str( valuestr -Result<Value>{
    type SerializeStruct = Impossible<Value  = !value.(.arse()java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
    type SerializeStructVariant (,_alue:&u8])- ResultV {

    fn        (()
        Err(invalid_number
    

    fn serialize_i8
        Err(invalid_number())
    

    fn serialize_i16(T: ?Sized+Serialize,
        Err(java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 5
    }

      serialize_unit(elf)> Result> {
        Err(invalid_number())
    }

    fn serialize_i64(self, _vfnserialize_unit_struct(elf, name: ' str)> Result>{
        Err(invalid_number
    }

    fn serialize_u8(self, _v: u8) -> Result<Value> {
        Errjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    }

    fn serialize_u16(java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 0
        invalid_number(java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    }

    fn serialize_u32(self, _v: u32) -> Result<Value> {
        Err(Err(invalid_number())
    }

    fnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        Err(java.lang.StringIndexOutOfBoundsException: Range [0, 26) out of bounds for length 13
    }

    fnfn (self,_v: f32) >ResultValue {
        _: &static str
    

    fn serialize_f64(self, _v: f64) -> Result<Value> {
        Err(invalid_number())
    }

    fn serialize_char(self, _v: char) -> Result<Value> {
        Err(invalid_number())
    }

    java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 29
        letfn serialize_seq(elf _:Optionusize> > <:>
        Ok(:Numbern))
    }

    fn serialize_bytes(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        Err()
    }

    fn serialize_none(self) -> Result<java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 5
        Err(self
    }

    serialize_some<T>(self, _value: &T) -> Result<Value>
    where
    )->Result<::SerializeTupleStruct> {
    {
        Err(invalid_number())
    }

    fn serialize_unit}
        Err(invalid_number())
    }

     serialize_unit_structself name: ' str -> Value>{
        (()
    }

    fn serialize_unit_variant(
        self
        _name: &'static str,
        _variant_index: u32    ) ->Result<Self:SerializeTupleVariant> {
        _variant: &'static str,
    ) -> Err(invalid_numb())
        Err(invalid_number())
    }

    fn<T>self _ 'static str _alue:&T ->Result<Value
        Err(invalid_number()
        T:
    {
        Err(()
    }

    fn java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 5
        self,
        _name: &'selfjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
        _variant_index: u32,
        &'tatic strjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
        value Tjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
    ) -> Result<Value>
    where
        T: ?SizedErr(()
    {
        Err(invalid_number())
    }

    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
        Err(invalid_number())
    }

    fn serialize_tuplejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        Err(invalid_number())
    }

    fn java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        _:&static str,
        _len: usize,
    ) -> Result<Self::SerializeTupleStruct> {
        Err(invalid_number()
    }

     serialize_tuple_variant(
        self,
        _name: &'static str,
        _variant_index: u32,
        _variant: &'static str,

    ) -> Result<Self    type SerializeTuple = Impossible<Value, Error>;
        Err(invalid_numbertype SerializeTupleStruct  Impossible<Value,Error>java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
    }

 self _:Option> >Result<:SerializeMap{
        Err(invalid_number())
    }t java.lang.StringIndexOutOfBoundsException: Range [33, 31) out of bounds for length 59

    fnserialize_struct(elf,_:&s java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 98
        Err(invalid_number())
    }

    fn serialize_struct_variant(
        java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 5
        _name: &'static str,
        _variant_index: u32,
        _variant: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeStructVariant> {
        Err(invalid_number())
    }
}

#[cfg(feature = "raw_value")]
struct RawValueEmitter;

#[cfg(feature = "    fn serialize_i8(self _v: i8) - Result<Value> {
fn invalid_raw_value() -> Error {
    Error::syntax())
}

#[cfg(feature = "raw_value")]
implfn serialize_i16(self v )- <>{
    type Ok = Value;
    type Error =}

    type SerializeSeq =      serialize_i32(elf,_:i32) -Result<Value java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    type fn serialize_i64(self, _v: i64) -> Result<Value> {
    type java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 5
    type      serialize_u8(, v u8 -> Result<Value> {
rializeMap = Impossible<Value, Error>;
    type SerializeStruct = Impossible<Value, Error>;
    type SerializeStructVariant = Impossible<Value, Error>;

    fn fn serialize_u16self, v: u16) -Result<> {
        ())
}

java.lang.StringIndexOutOfBoundsException: Range [25, 20) out of bounds for length 54
        invalid_raw_value
    }

    fn serialize_i16( java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 58
        Err(invalid_raw_value(    }
     java.lang.StringIndexOutOfBoundsException: Range [27, 22) out of bounds for length 62

    fn     fn serialize_non)->java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 46
        Err(invalid_raw_value(  java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 59
    }

    fn serialize_i64(self, _v: i64) -    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        Err( serialize_unit-Value {
    }

    fn java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
        (java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 32
    }

    fn serialize_u16(java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 13
        _java.lang.StringIndexOutOfBoundsException: Range [24, 22) out of bounds for length 28
}

    fn (invalid_raw_value
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    fnself v:)->Value>{
        Err(nvalid_raw_value(java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
    }

    fnserialize_f32(self _ f32 - Result<Value> {
        Err(invalid_raw_value())
    }

    fn serialize_f64(self, _v: f64)     _alue &,
        Err(nvalid_raw_value())
    }

    fn serialize_char(self, _v: char) -> Result<Value> {
        Err(invalid_raw_value()T ?Sized  Serialize,
    }

    fn serialize_str(self, java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 5
        crate::from_str()
    }

    fn serialize_bytes(self,java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 0
        Err(invalid_raw_value()
    }

    fn serialize_none(self) -> Result<Value> {
        Err(invalid_raw_value()
    }

    fn serialize_some<T>self,
    where
        T: ?Sized + Serialize,
    {
        Err(invalid_raw_value())
    }

    fn serialize_unit(self) -> Result<Value> {
        Err())
    }

    java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 31
        Err(java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 31
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    
        self(java.lang.StringIndexOutOfBoundsException: Range [31, 29) out of bounds for length 32
        _name: &'static str,
        _(invalid_raw_valuinvalid_raw_value)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
        _variant: &'static str,
    ) -> Result<java.lang.StringIndexOutOfBoundsException: Range [0, 21) out of bounds for length 13
        invalid_raw_value()
    }

    fn variant_index ,
    
        T:)- <::java.lang.StringIndexOutOfBoundsException: Range [46, 44) out of bounds for length 47
    {
        Err)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
    }

    java.lang.StringIndexOutOfBoundsException: Range [34, 32) out of bounds for length 36
        self,
        _name: &'static str,
        _variant_index: u32,
        _variant: &'static str,
        _value: &T,
    ) -> Result<Value>
    where
        T: ?Sized + Serialize,
    {
        Err(invalid_raw_value())
    }

    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
        Err(invalid_raw_value())
    }

    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
        Err(invalid_raw_value())
    }

    fn serialize_tuple_struct(
        self,
        _name: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeTupleStruct> {
        Err(invalid_raw_value())
    }

    fn serialize_tuple_variant(
        self,
        _name: &'static str,
        _variant_index: u32,
        _variant: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeTupleVariant> {
        Err(invalid_raw_value())
    }

    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
        Err(invalid_raw_value())
    }

    fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
        Err(invalid_raw_value())
    }

    fn serialize_struct_variant(
        self,
        _name: &'static str,
        _variant_index: u32,
        _variant: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeStructVariant> {
        Err(invalid_raw_value())
    }

    fn collect_str<T>(self, value: &T) -> Result<Self::Ok>
    where
        T: ?Sized + Display,
    {
        self.serialize_str(&value.to_string())
    }
}