#![feature(prelude_import)]
#![no_std]
#[prelude_import]
use ::std::prelude::v1::*;
#[macro_use]
extern crate std as std;
extern crate pm_lexer as lexer;
use pomelo::pomelo;
use std::collections::HashMap;
pub enum JObject {
    JDict(HashMap<String, JObject>),
    JArray(Vec<JObject>),
    JNumber(i64),
    JString(String),
    JBool(bool),
    JNull,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::std::fmt::Debug for JObject {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        match (&*self,) {
            (&JObject::JDict(ref __self_0),) => {
                let mut debug_trait_builder = f.debug_tuple("JDict");
                let _ = debug_trait_builder.field(&&(*__self_0));
                debug_trait_builder.finish()
            }
            (&JObject::JArray(ref __self_0),) => {
                let mut debug_trait_builder = f.debug_tuple("JArray");
                let _ = debug_trait_builder.field(&&(*__self_0));
                debug_trait_builder.finish()
            }
            (&JObject::JNumber(ref __self_0),) => {
                let mut debug_trait_builder = f.debug_tuple("JNumber");
                let _ = debug_trait_builder.field(&&(*__self_0));
                debug_trait_builder.finish()
            }
            (&JObject::JString(ref __self_0),) => {
                let mut debug_trait_builder = f.debug_tuple("JString");
                let _ = debug_trait_builder.field(&&(*__self_0));
                debug_trait_builder.finish()
            }
            (&JObject::JBool(ref __self_0),) => {
                let mut debug_trait_builder = f.debug_tuple("JBool");
                let _ = debug_trait_builder.field(&&(*__self_0));
                debug_trait_builder.finish()
            }
            (&JObject::JNull,) => {
                let mut debug_trait_builder = f.debug_tuple("JNull");
                debug_trait_builder.finish()
            }
        }
    }
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::std::clone::Clone for JObject {
    #[inline]
    fn clone(&self) -> JObject {
        match (&*self,) {
            (&JObject::JDict(ref __self_0),) => {
                JObject::JDict(::std::clone::Clone::clone(&(*__self_0)))
            }
            (&JObject::JArray(ref __self_0),) => {
                JObject::JArray(::std::clone::Clone::clone(&(*__self_0)))
            }
            (&JObject::JNumber(ref __self_0),) => {
                JObject::JNumber(::std::clone::Clone::clone(&(*__self_0)))
            }
            (&JObject::JString(ref __self_0),) => {
                JObject::JString(::std::clone::Clone::clone(&(*__self_0)))
            }
            (&JObject::JBool(ref __self_0),) => {
                JObject::JBool(::std::clone::Clone::clone(&(*__self_0)))
            }
            (&JObject::JNull,) => JObject::JNull,
        }
    }
}
impl std::str::FromStr for JObject {
    type Err = String;
    fn from_str(input: &str) -> Result<JObject, String> {
        let mut p = json::Parser::new();
        let tok_stream = input.parse().map_err(|_| "Lexer Error")?;
        lexer::parse::<String, _>(tok_stream, |tk| {
            use proc_macro2::TokenTree;
            let tk = match tk {
                TokenTree::Punct(p) => match p.as_char() {
                    '{' => json::Token::LBrace,
                    '}' => json::Token::RBrace,
                    '[' => json::Token::LBracket,
                    ']' => json::Token::RBracket,
                    ',' => json::Token::Comma,
                    ':' => json::Token::Colon,
                    c => {
                        return Err(::alloc::fmt::format(::std::fmt::Arguments::new_v1(
                            &["Invalid character \'", "\'"],
                            &match (&c,) {
                                (arg0,) => {
                                    [::std::fmt::ArgumentV1::new(arg0, ::std::fmt::Display::fmt)]
                                }
                            },
                        )));
                    }
                },
                TokenTree::Literal(l) => {
                    let s = l.to_string();
                    if s.starts_with('"') && s.ends_with('"') {
                        let bs = s.into_bytes();
                        let s = std::str::from_utf8(&bs[1..bs.len() - 1])
                            .unwrap()
                            .to_string();
                        json::Token::JString(s)
                    } else {
                        let i = s.parse().map_err(|_| "Invalid integer value")?;
                        json::Token::JNumber(i)
                    }
                }
                TokenTree::Ident(i) => {
                    let s = i.to_string();
                    if s == "true" {
                        json::Token::JBool(true)
                    } else if s == "false" {
                        json::Token::JBool(false)
                    } else if s == "null" {
                        json::Token::JNull
                    } else {
                        return Err(::alloc::fmt::format(::std::fmt::Arguments::new_v1(
                            &["Invalid token \'", "\'"],
                            &match (&s,) {
                                (arg0,) => {
                                    [::std::fmt::ArgumentV1::new(arg0, ::std::fmt::Display::fmt)]
                                }
                            },
                        )));
                    }
                }
                _ => ::std::rt::begin_panic(
                    "not yet implemented",
                    &("examples/json.rs", 55u32, 22u32),
                ),
            };
            p.parse(tk).map_err(|_| "Parser error")?;
            Ok(())
        })?;
        let j = p.end_of_input().map_err(|_| "Parser error")?;
        Ok(j)
    }
}
mod json {
    #![allow(dead_code)]
    #![allow(unreachable_code)]
    #![allow(unused_variables)]
    #![allow(non_snake_case)]
    use super::JObject;
    use std::collections::HashMap;
    const YYNOCODE: i32 = 22i32;
    const YYWILDCARD: i8 = 0;
    type YYStack<T> = std::vec::Vec<T>;
    const YYSTACKLIMIT: usize = 100usize;
    enum YYMinorType {
        YY_(::core::marker::PhantomData<Parser>),
        YY0(()),
        YY7((String, JObject)),
        YY9(Option<Vec<JObject>>),
        YY4(JObject),
        YY1(i64),
        YY8(Option<HashMap<String, JObject>>),
        YY3(bool),
        YY2(String),
        YY5(Vec<JObject>),
        YY6(HashMap<String, JObject>),
    }
    const YYNSTATE: i32 = 25;
    const YYNRULE: i32 = 18;
    const YYERRORSYMBOL: i32 = 0;
    pub enum Token {
        JNumber(i64),
        JString(String),
        JBool(bool),
        JNull,
        LBrace,
        RBrace,
        LBracket,
        RBracket,
        Comma,
        Colon,
    }
    #[automatically_derived]
    #[allow(unused_qualifications)]
    impl ::std::fmt::Debug for Token {
        fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
            match (&*self,) {
                (&Token::JNumber(ref __self_0),) => {
                    let mut debug_trait_builder = f.debug_tuple("JNumber");
                    let _ = debug_trait_builder.field(&&(*__self_0));
                    debug_trait_builder.finish()
                }
                (&Token::JString(ref __self_0),) => {
                    let mut debug_trait_builder = f.debug_tuple("JString");
                    let _ = debug_trait_builder.field(&&(*__self_0));
                    debug_trait_builder.finish()
                }
                (&Token::JBool(ref __self_0),) => {
                    let mut debug_trait_builder = f.debug_tuple("JBool");
                    let _ = debug_trait_builder.field(&&(*__self_0));
                    debug_trait_builder.finish()
                }
                (&Token::JNull,) => {
                    let mut debug_trait_builder = f.debug_tuple("JNull");
                    debug_trait_builder.finish()
                }
                (&Token::LBrace,) => {
                    let mut debug_trait_builder = f.debug_tuple("LBrace");
                    debug_trait_builder.finish()
                }
                (&Token::RBrace,) => {
                    let mut debug_trait_builder = f.debug_tuple("RBrace");
                    debug_trait_builder.finish()
                }
                (&Token::LBracket,) => {
                    let mut debug_trait_builder = f.debug_tuple("LBracket");
                    debug_trait_builder.finish()
                }
                (&Token::RBracket,) => {
                    let mut debug_trait_builder = f.debug_tuple("RBracket");
                    debug_trait_builder.finish()
                }
                (&Token::Comma,) => {
                    let mut debug_trait_builder = f.debug_tuple("Comma");
                    debug_trait_builder.finish()
                }
                (&Token::Colon,) => {
                    let mut debug_trait_builder = f.debug_tuple("Colon");
                    debug_trait_builder.finish()
                }
            }
        }
    }
    #[inline]
    fn token_value(t: Token) -> (i32, YYMinorType) {
        match t {
            Token::JNumber(x) => (1i32, YYMinorType::YY1(x)),
            Token::JString(x) => (2i32, YYMinorType::YY2(x)),
            Token::JBool(x) => (3i32, YYMinorType::YY3(x)),
            Token::JNull => (4i32, YYMinorType::YY0(())),
            Token::LBrace => (5i32, YYMinorType::YY0(())),
            Token::RBrace => (6i32, YYMinorType::YY0(())),
            Token::LBracket => (7i32, YYMinorType::YY0(())),
            Token::RBracket => (8i32, YYMinorType::YY0(())),
            Token::Comma => (9i32, YYMinorType::YY0(())),
            Token::Colon => (10i32, YYMinorType::YY0(())),
        }
    }
    fn token_build(i: i32, yy: YYMinorType) -> Option<Token> {
        match (i, yy) {
            (1i32, YYMinorType::YY1(x)) => Some(Token::JNumber(x)),
            (2i32, YYMinorType::YY2(x)) => Some(Token::JString(x)),
            (3i32, YYMinorType::YY3(x)) => Some(Token::JBool(x)),
            (4i32, _) => Some(Token::JNull),
            (5i32, _) => Some(Token::LBrace),
            (6i32, _) => Some(Token::RBrace),
            (7i32, _) => Some(Token::LBracket),
            (8i32, _) => Some(Token::RBracket),
            (9i32, _) => Some(Token::Comma),
            (10i32, _) => Some(Token::Colon),
            _ => None,
        }
    }
    static YY_ACTION: [i32; 32usize] = [
        22, 21, 20, 19, 4, 25, 1, 14, 24, 23, 6, 12, 24, 23, 7, 44, 11, 24, 23, 9, 17, 10, 13, 24,
        23, 18, 5, 8, 3, 15, 16, 2,
    ];
    static YY_LOOKAHEAD: [i8; 32usize] = [
        1, 2, 3, 4, 5, 0, 7, 13, 14, 15, 16, 13, 14, 15, 20, 12, 13, 14, 15, 17, 18, 19, 13, 14,
        15, 6, 9, 2, 10, 8, 18, 9,
    ];
    const YY_SHIFT_USE_DFLT: i32 = -2i32;
    const YY_SHIFT_COUNT: i32 = 11usize as i32;
    const YY_SHIFT_MIN: i32 = -1i32;
    const YY_SHIFT_MAX: i32 = 25i32;
    static YY_SHIFT_OFST: [i8; 12usize] = [-1, -1, -1, -1, 25, 25, 22, 21, 18, 17, 19, 5];
    const YY_REDUCE_USE_DFLT: i32 = -7i32;
    const YY_REDUCE_COUNT: i32 = 5usize as i32;
    const YY_REDUCE_MIN: i32 = -6i32;
    const YY_REDUCE_MAX: i32 = 12i32;
    static YY_REDUCE_OFST: [i8; 6usize] = [3, -6, 9, -2, 2, 12];
    static YY_DEFAULT: [u8; 25usize] = [
        43, 39, 43, 43, 41, 43, 40, 43, 43, 42, 43, 43, 38, 35, 34, 33, 37, 36, 32, 31, 30, 29, 28,
        27, 26,
    ];
    static YY_FALLBACK: [i32; 0usize] = [];
    static YY_RULE_INFO: [i8; 18usize] = [
        12, 13, 13, 13, 13, 13, 13, 14, 15, 16, 16, 17, 17, 18, 20, 20, 19, 19,
    ];
    struct YYStackEntry {
        stateno: i32,
        major: i32,
        minor: YYMinorType,
    }
    enum YYStatus<T> {
        Normal,
        Failed,
        Accepted(T),
    }
    impl<T> YYStatus<T> {
        fn unwrap(self) -> T {
            match self {
                YYStatus::Accepted(t) => t,
                _ => ::std::rt::begin_panic_fmt(
                    &::std::fmt::Arguments::new_v1(
                        &["internal error: entered unreachable code: "],
                        &match (&"accepted without data",) {
                            (arg0,) => {
                                [::std::fmt::ArgumentV1::new(arg0, ::std::fmt::Display::fmt)]
                            }
                        },
                    ),
                    &("examples/json.rs", 65u32, 1u32),
                ),
            }
        }
        fn is_normal(&self) -> bool {
            match self {
                YYStatus::Normal => true,
                _ => false,
            }
        }
    }
    pub(crate) struct Parser {
        error_count: u8,
        yystack: YYStack<YYStackEntry>,
        extra: (),
        yystatus: YYStatus<JObject>,
    }
    impl Parser {
        pub fn new() -> Self {
            Self::new_priv(())
        }
        pub fn end_of_input(mut self) -> Result<JObject, ()> {
            self.end_of_input_priv().map(|r| r.0)
        }
        pub fn parse(&mut self, token: Token) -> Result<(), ()> {
            let (a, b) = token_value(token);
            yy_parse_token(self, a, b)
        }
        fn new_priv(extra: ()) -> Self {
            let mut yystack = YYStack::new();
            yystack.push(YYStackEntry {
                stateno: 0,
                major: 0,
                minor: YYMinorType::YY0(()),
            });
            Parser {
                error_count: 0,
                yystack,
                extra,
                yystatus: YYStatus::Normal,
            }
        }
        fn end_of_input_priv(mut self) -> Result<(JObject, ()), ()> {
            yy_parse_token(&mut self, 0, YYMinorType::YY0(()))?;
            Ok((self.yystatus.unwrap(), self.extra))
        }
    }
    fn yy_parse_token(yy: &mut Parser, yymajor: i32, yyminor: YYMinorType) -> Result<(), ()> {
        if !yy.yystatus.is_normal() {
            {
                ::std::rt::begin_panic(
                    "Cannot call parse after failure",
                    &("examples/json.rs", 65u32, 1u32),
                )
            };
        }
        let res = yy_parse_token_2(yy, yymajor, yyminor);
        if res.is_err() {
            yy.yystatus = YYStatus::Failed;
        }
        res
    }
    fn yy_parse_token_2(yy: &mut Parser, yymajor: i32, yyminor: YYMinorType) -> Result<(), ()> {
        while yy.yystatus.is_normal() {
            let yyact = yy_find_shift_action(yy, yymajor);
            if yyact < YYNSTATE {
                if !(yymajor != 0) {
                    {
                        ::std::rt::begin_panic(
                            "assertion failed: yymajor != 0",
                            &("examples/json.rs", 65u32, 1u32),
                        )
                    }
                };
                yy_shift(yy, yyact, yymajor, yyminor)?;
                yy.error_count = yy.error_count.saturating_sub(1);
                break;
            } else if yyact < YYNSTATE + YYNRULE {
                yy_reduce(yy, yyact - YYNSTATE)?;
            } else {
                if !(yyact == YYNSTATE + YYNRULE) {
                    {
                        ::std::rt::begin_panic(
                            "assertion failed: yyact == YYNSTATE + YYNRULE",
                            &("examples/json.rs", 65u32, 1u32),
                        )
                    }
                };
                if YYERRORSYMBOL != 0 {
                    if yymajor == 0 {
                        return Err(yy_parse_failed(yy));
                    }
                    while let Some(top) = yy.yystack.last() {
                        if top.major == YYERRORSYMBOL {
                            break;
                        }
                        let yyact = yy_find_reduce_action(yy, YYERRORSYMBOL);
                        if yyact < YYNSTATE {
                            let e = yy_syntax_error(yy, yymajor, yyminor)?;
                            yy_shift(yy, yyact, YYERRORSYMBOL, e)?;
                            break;
                        }
                        yy.yystack.pop().unwrap();
                    }
                    if yy.yystack.is_empty() {
                        return Err(yy_parse_failed(yy));
                    }
                    yy.error_count = 3;
                    break;
                } else {
                    if yymajor == 0 {
                        return Err(yy_parse_failed(yy));
                    }
                    if yy.error_count == 0 {
                        yy_syntax_error(yy, yymajor, yyminor)?;
                    }
                    yy.error_count = 3;
                    break;
                }
            }
        }
        Ok(())
    }
    fn yy_find_shift_action(yy: &mut Parser, look_ahead: i32) -> i32 {
        let stateno = yy.yystack.last().unwrap().stateno;
        if stateno > YY_SHIFT_COUNT {
            return YY_DEFAULT[stateno as usize] as i32;
        }
        let i = YY_SHIFT_OFST[stateno as usize] as i32;
        if i == YY_SHIFT_USE_DFLT {
            return YY_DEFAULT[stateno as usize] as i32;
        }
        if !(look_ahead != YYNOCODE) {
            {
                ::std::rt::begin_panic(
                    "assertion failed: look_ahead != YYNOCODE",
                    &("examples/json.rs", 65u32, 1u32),
                )
            }
        };
        let i = i + look_ahead;
        if i < 0 || i >= YY_ACTION.len() as i32 || YY_LOOKAHEAD[i as usize] as i32 != look_ahead {
            if look_ahead > 0 {
                if (look_ahead as usize) < YY_FALLBACK.len() {
                    let fallback = YY_FALLBACK[look_ahead as usize];
                    if fallback != 0 {
                        return yy_find_shift_action(yy, fallback);
                    }
                }
                if YYWILDCARD > 0 {
                    let j = i - look_ahead + (YYWILDCARD as i32);
                    if j >= 0
                        && j < YY_ACTION.len() as i32
                        && YY_LOOKAHEAD[j as usize] == YYWILDCARD
                    {
                        return YY_ACTION[j as usize] as i32;
                    }
                }
            }
            return YY_DEFAULT[stateno as usize] as i32;
        } else {
            return YY_ACTION[i as usize] as i32;
        }
    }
    fn yy_find_reduce_action(yy: &mut Parser, look_ahead: i32) -> i32 {
        let stateno = yy.yystack.last().unwrap().stateno;
        if YYERRORSYMBOL != 0 && stateno > YY_REDUCE_COUNT {
            return YY_DEFAULT[stateno as usize] as i32;
        }
        if !(stateno <= YY_REDUCE_COUNT) {
            {
                ::std::rt::begin_panic(
                    "assertion failed: stateno <= YY_REDUCE_COUNT",
                    &("examples/json.rs", 65u32, 1u32),
                )
            }
        };
        let i = YY_REDUCE_OFST[stateno as usize] as i32;
        if !(i != YY_REDUCE_USE_DFLT) {
            {
                ::std::rt::begin_panic(
                    "assertion failed: i != YY_REDUCE_USE_DFLT",
                    &("examples/json.rs", 65u32, 1u32),
                )
            }
        };
        if !(look_ahead != YYNOCODE) {
            {
                ::std::rt::begin_panic(
                    "assertion failed: look_ahead != YYNOCODE",
                    &("examples/json.rs", 65u32, 1u32),
                )
            }
        };
        let i = i + look_ahead;
        if YYERRORSYMBOL != 0
            && (i < 0
                || i >= YY_ACTION.len() as i32
                || YY_LOOKAHEAD[i as usize] as i32 != look_ahead)
        {
            return YY_DEFAULT[stateno as usize] as i32;
        }
        if !(i >= 0 && i < YY_ACTION.len() as i32) {
            {
                ::std::rt::begin_panic(
                    "assertion failed: i >= 0 && i < YY_ACTION.len() as i32",
                    &("examples/json.rs", 65u32, 1u32),
                )
            }
        };
        if !(YY_LOOKAHEAD[i as usize] as i32 == look_ahead) {
            {
                ::std::rt::begin_panic(
                    "assertion failed: YY_LOOKAHEAD[i as usize] as i32 == look_ahead",
                    &("examples/json.rs", 65u32, 1u32),
                )
            }
        };
        return YY_ACTION[i as usize] as i32;
    }
    fn yy_shift(
        yy: &mut Parser,
        new_state: i32,
        yymajor: i32,
        yyminor: YYMinorType,
    ) -> Result<(), ()> {
        if YYSTACKLIMIT != 0 && yy.yystack.len() >= YYSTACKLIMIT {
            let token = token_build(yymajor, yyminor);
            let extra = &mut yy.extra;
            return Err({ Default::default() });
        }
        yy.yystack.push(YYStackEntry {
            stateno: new_state,
            major: yymajor,
            minor: yyminor,
        });
        Ok(())
    }
    fn yy_parse_failed(yy: &mut Parser) -> () {
        yy.yystack.clear();
        let extra = &mut yy.extra;
        {
            Default::default()
        }
    }
    fn yy_syntax_error_2(yy: &mut Parser, yymajor: i32, yyminor: YYMinorType) -> Result<(), ()> {
        let token = token_build(yymajor, yyminor);
        let extra = &mut yy.extra;
        {
            Err(Default::default())
        }
    }
    fn yy_syntax_error(
        yy: &mut Parser,
        yymajor: i32,
        yyminor: YYMinorType,
    ) -> Result<YYMinorType, ()> {
        let e = yy_syntax_error_2(yy, yymajor, yyminor)?;
        Ok(YYMinorType::YY0(e))
    }
    fn yy_reduce(yy: &mut Parser, yyruleno: i32) -> Result<(), ()> {
        let yygotominor: YYMinorType = match (yyruleno, &mut yy.extra) {
            (0i32, extra) => {
                let yyp0 = yy.yystack.pop().unwrap();
                let yyres: JObject = match (yyp0.minor) {
                    (YYMinorType::YY4(J)) => J,
                    _ => ::std::rt::begin_panic_fmt(
                        &::std::fmt::Arguments::new_v1(
                            &["internal error: entered unreachable code: "],
                            &match (&"impossible pattern",) {
                                (arg0,) => {
                                    [::std::fmt::ArgumentV1::new(arg0, ::std::fmt::Display::fmt)]
                                }
                            },
                        ),
                        &("examples/json.rs", 65u32, 1u32),
                    ),
                };
                YYMinorType::YY4(yyres)
            }
            (1i32, extra) => {
                let yyp0 = yy.yystack.pop().unwrap();
                let yyres: JObject = match (yyp0.minor) {
                    (YYMinorType::YY4(D)) => D,
                    _ => ::std::rt::begin_panic_fmt(
                        &::std::fmt::Arguments::new_v1(
                            &["internal error: entered unreachable code: "],
                            &match (&"impossible pattern",) {
                                (arg0,) => {
                                    [::std::fmt::ArgumentV1::new(arg0, ::std::fmt::Display::fmt)]
                                }
                            },
                        ),
                        &("examples/json.rs", 65u32, 1u32),
                    ),
                };
                YYMinorType::YY4(yyres)
            }
            (2i32, extra) => {
                let yyp0 = yy.yystack.pop().unwrap();
                let yyres: JObject = match (yyp0.minor) {
                    (YYMinorType::YY4(A)) => A,
                    _ => ::std::rt::begin_panic_fmt(
                        &::std::fmt::Arguments::new_v1(
                            &["internal error: entered unreachable code: "],
                            &match (&"impossible pattern",) {
                                (arg0,) => {
                                    [::std::fmt::ArgumentV1::new(arg0, ::std::fmt::Display::fmt)]
                                }
                            },
                        ),
                        &("examples/json.rs", 65u32, 1u32),
                    ),
                };
                YYMinorType::YY4(yyres)
            }
            (3i32, extra) => {
                let yyp0 = yy.yystack.pop().unwrap();
                let yyres: JObject = match (yyp0.minor) {
                    (YYMinorType::YY1(N)) => JObject::JNumber(N),
                    _ => ::std::rt::begin_panic_fmt(
                        &::std::fmt::Arguments::new_v1(
                            &["internal error: entered unreachable code: "],
                            &match (&"impossible pattern",) {
                                (arg0,) => {
                                    [::std::fmt::ArgumentV1::new(arg0, ::std::fmt::Display::fmt)]
                                }
                            },
                        ),
                        &("examples/json.rs", 65u32, 1u32),
                    ),
                };
                YYMinorType::YY4(yyres)
            }
            (4i32, extra) => {
                let yyp0 = yy.yystack.pop().unwrap();
                let yyres: JObject = match (yyp0.minor) {
                    (YYMinorType::YY2(S)) => JObject::JString(S),
                    _ => ::std::rt::begin_panic_fmt(
                        &::std::fmt::Arguments::new_v1(
                            &["internal error: entered unreachable code: "],
                            &match (&"impossible pattern",) {
                                (arg0,) => {
                                    [::std::fmt::ArgumentV1::new(arg0, ::std::fmt::Display::fmt)]
                                }
                            },
                        ),
                        &("examples/json.rs", 65u32, 1u32),
                    ),
                };
                YYMinorType::YY4(yyres)
            }
            (5i32, extra) => {
                let yyp0 = yy.yystack.pop().unwrap();
                let yyres: JObject = match (yyp0.minor) {
                    (YYMinorType::YY3(B)) => JObject::JBool(B),
                    _ => ::std::rt::begin_panic_fmt(
                        &::std::fmt::Arguments::new_v1(
                            &["internal error: entered unreachable code: "],
                            &match (&"impossible pattern",) {
                                (arg0,) => {
                                    [::std::fmt::ArgumentV1::new(arg0, ::std::fmt::Display::fmt)]
                                }
                            },
                        ),
                        &("examples/json.rs", 65u32, 1u32),
                    ),
                };
                YYMinorType::YY4(yyres)
            }
            (6i32, extra) => {
                let yyp0 = yy.yystack.pop().unwrap();
                let yyres: JObject = match (yyp0.minor) {
                    (_) => JObject::JNull,
                    _ => ::std::rt::begin_panic_fmt(
                        &::std::fmt::Arguments::new_v1(
                            &["internal error: entered unreachable code: "],
                            &match (&"impossible pattern",) {
                                (arg0,) => {
                                    [::std::fmt::ArgumentV1::new(arg0, ::std::fmt::Display::fmt)]
                                }
                            },
                        ),
                        &("examples/json.rs", 65u32, 1u32),
                    ),
                };
                YYMinorType::YY4(yyres)
            }
            (7i32, extra) => {
                let yyp2 = yy.yystack.pop().unwrap();
                let yyp1 = yy.yystack.pop().unwrap();
                let yyp0 = yy.yystack.pop().unwrap();
                let yyres: JObject = match (yyp0.minor, yyp1.minor, yyp2.minor) {
                    (_, YYMinorType::YY8(D), _) => JObject::JDict(D.unwrap_or_else(HashMap::new)),
                    _ => ::std::rt::begin_panic_fmt(
                        &::std::fmt::Arguments::new_v1(
                            &["internal error: entered unreachable code: "],
                            &match (&"impossible pattern",) {
                                (arg0,) => {
                                    [::std::fmt::ArgumentV1::new(arg0, ::std::fmt::Display::fmt)]
                                }
                            },
                        ),
                        &("examples/json.rs", 65u32, 1u32),
                    ),
                };
                YYMinorType::YY4(yyres)
            }
            (8i32, extra) => {
                let yyp2 = yy.yystack.pop().unwrap();
                let yyp1 = yy.yystack.pop().unwrap();
                let yyp0 = yy.yystack.pop().unwrap();
                let yyres: JObject = match (yyp0.minor, yyp1.minor, yyp2.minor) {
                    (_, YYMinorType::YY9(A), _) => JObject::JArray(A.unwrap_or_else(Vec::new)),
                    _ => ::std::rt::begin_panic_fmt(
                        &::std::fmt::Arguments::new_v1(
                            &["internal error: entered unreachable code: "],
                            &match (&"impossible pattern",) {
                                (arg0,) => {
                                    [::std::fmt::ArgumentV1::new(arg0, ::std::fmt::Display::fmt)]
                                }
                            },
                        ),
                        &("examples/json.rs", 65u32, 1u32),
                    ),
                };
                YYMinorType::YY4(yyres)
            }
            (9i32, extra) => {
                let yyp0 = yy.yystack.pop().unwrap();
                let yyres: Vec<JObject> = match (yyp0.minor) {
                    (YYMinorType::YY4(J)) => <[_]>::into_vec(box [J]),
                    _ => ::std::rt::begin_panic_fmt(
                        &::std::fmt::Arguments::new_v1(
                            &["internal error: entered unreachable code: "],
                            &match (&"impossible pattern",) {
                                (arg0,) => {
                                    [::std::fmt::ArgumentV1::new(arg0, ::std::fmt::Display::fmt)]
                                }
                            },
                        ),
                        &("examples/json.rs", 65u32, 1u32),
                    ),
                };
                YYMinorType::YY5(yyres)
            }
            (10i32, extra) => {
                let yyp2 = yy.yystack.pop().unwrap();
                let yyp1 = yy.yystack.pop().unwrap();
                let yyp0 = yy.yystack.pop().unwrap();
                let yyres: Vec<JObject> = match (yyp0.minor, yyp1.minor, yyp2.minor) {
                    (YYMinorType::YY5(mut A), _, YYMinorType::YY4(J)) => {
                        A.push(J);
                        A
                    }
                    _ => ::std::rt::begin_panic_fmt(
                        &::std::fmt::Arguments::new_v1(
                            &["internal error: entered unreachable code: "],
                            &match (&"impossible pattern",) {
                                (arg0,) => {
                                    [::std::fmt::ArgumentV1::new(arg0, ::std::fmt::Display::fmt)]
                                }
                            },
                        ),
                        &("examples/json.rs", 65u32, 1u32),
                    ),
                };
                YYMinorType::YY5(yyres)
            }
            (11i32, extra) => {
                let yyp0 = yy.yystack.pop().unwrap();
                let yyres: HashMap<String, JObject> = match (yyp0.minor) {
                    (YYMinorType::YY7((K, V))) => {
                        let mut d = HashMap::new();
                        d.insert(K, V);
                        d
                    }
                    _ => ::std::rt::begin_panic_fmt(
                        &::std::fmt::Arguments::new_v1(
                            &["internal error: entered unreachable code: "],
                            &match (&"impossible pattern",) {
                                (arg0,) => {
                                    [::std::fmt::ArgumentV1::new(arg0, ::std::fmt::Display::fmt)]
                                }
                            },
                        ),
                        &("examples/json.rs", 65u32, 1u32),
                    ),
                };
                YYMinorType::YY6(yyres)
            }
            (12i32, extra) => {
                let yyp2 = yy.yystack.pop().unwrap();
                let yyp1 = yy.yystack.pop().unwrap();
                let yyp0 = yy.yystack.pop().unwrap();
                let yyres: HashMap<String, JObject> = match (yyp0.minor, yyp1.minor, yyp2.minor) {
                    (YYMinorType::YY6(mut A), _, YYMinorType::YY7((K, V))) => {
                        A.insert(K, V);
                        A
                    }
                    _ => ::std::rt::begin_panic_fmt(
                        &::std::fmt::Arguments::new_v1(
                            &["internal error: entered unreachable code: "],
                            &match (&"impossible pattern",) {
                                (arg0,) => {
                                    [::std::fmt::ArgumentV1::new(arg0, ::std::fmt::Display::fmt)]
                                }
                            },
                        ),
                        &("examples/json.rs", 65u32, 1u32),
                    ),
                };
                YYMinorType::YY6(yyres)
            }
            (13i32, extra) => {
                let yyp2 = yy.yystack.pop().unwrap();
                let yyp1 = yy.yystack.pop().unwrap();
                let yyp0 = yy.yystack.pop().unwrap();
                let yyres: (String, JObject) = match (yyp0.minor, yyp1.minor, yyp2.minor) {
                    (YYMinorType::YY2(K), _, YYMinorType::YY4(V)) => (K, V),
                    _ => ::std::rt::begin_panic_fmt(
                        &::std::fmt::Arguments::new_v1(
                            &["internal error: entered unreachable code: "],
                            &match (&"impossible pattern",) {
                                (arg0,) => {
                                    [::std::fmt::ArgumentV1::new(arg0, ::std::fmt::Display::fmt)]
                                }
                            },
                        ),
                        &("examples/json.rs", 65u32, 1u32),
                    ),
                };
                YYMinorType::YY7(yyres)
            }
            (14i32, extra) => {
                let yyres: Option<Vec<JObject>> = match () {
                    () => None,
                    _ => ::std::rt::begin_panic_fmt(
                        &::std::fmt::Arguments::new_v1(
                            &["internal error: entered unreachable code: "],
                            &match (&"impossible pattern",) {
                                (arg0,) => {
                                    [::std::fmt::ArgumentV1::new(arg0, ::std::fmt::Display::fmt)]
                                }
                            },
                        ),
                        &("examples/json.rs", 65u32, 1u32),
                    ),
                };
                YYMinorType::YY9(yyres)
            }
            (15i32, extra) => {
                let yyp0 = yy.yystack.pop().unwrap();
                let yyres: Option<Vec<JObject>> = match (yyp0.minor) {
                    (YYMinorType::YY5(_A)) => Some(_A),
                    _ => ::std::rt::begin_panic_fmt(
                        &::std::fmt::Arguments::new_v1(
                            &["internal error: entered unreachable code: "],
                            &match (&"impossible pattern",) {
                                (arg0,) => {
                                    [::std::fmt::ArgumentV1::new(arg0, ::std::fmt::Display::fmt)]
                                }
                            },
                        ),
                        &("examples/json.rs", 65u32, 1u32),
                    ),
                };
                YYMinorType::YY9(yyres)
            }
            (16i32, extra) => {
                let yyres: Option<HashMap<String, JObject>> = match () {
                    () => None,
                    _ => ::std::rt::begin_panic_fmt(
                        &::std::fmt::Arguments::new_v1(
                            &["internal error: entered unreachable code: "],
                            &match (&"impossible pattern",) {
                                (arg0,) => {
                                    [::std::fmt::ArgumentV1::new(arg0, ::std::fmt::Display::fmt)]
                                }
                            },
                        ),
                        &("examples/json.rs", 65u32, 1u32),
                    ),
                };
                YYMinorType::YY8(yyres)
            }
            (17i32, extra) => {
                let yyp0 = yy.yystack.pop().unwrap();
                let yyres: Option<HashMap<String, JObject>> = match (yyp0.minor) {
                    (YYMinorType::YY6(_A)) => Some(_A),
                    _ => ::std::rt::begin_panic_fmt(
                        &::std::fmt::Arguments::new_v1(
                            &["internal error: entered unreachable code: "],
                            &match (&"impossible pattern",) {
                                (arg0,) => {
                                    [::std::fmt::ArgumentV1::new(arg0, ::std::fmt::Display::fmt)]
                                }
                            },
                        ),
                        &("examples/json.rs", 65u32, 1u32),
                    ),
                };
                YYMinorType::YY8(yyres)
            }
            _ => ::std::rt::begin_panic_fmt(
                &::std::fmt::Arguments::new_v1(
                    &["internal error: entered unreachable code: "],
                    &match (&"no rule to apply",) {
                        (arg0,) => [::std::fmt::ArgumentV1::new(arg0, ::std::fmt::Display::fmt)],
                    },
                ),
                &("examples/json.rs", 65u32, 1u32),
            ),
        };
        let yygoto = YY_RULE_INFO[yyruleno as usize] as i32;
        let yyact = yy_find_reduce_action(yy, yygoto);
        if yyact < YYNSTATE {
            yy_shift(yy, yyact, yygoto, yygotominor)?;
            Ok(())
        } else {
            if !(yyact == YYNSTATE + YYNRULE + 1) {
                {
                    ::std::rt::begin_panic(
                        "assertion failed: yyact == YYNSTATE + YYNRULE + 1",
                        &("examples/json.rs", 65u32, 1u32),
                    )
                }
            };
            if let YYMinorType::YY4(root) = yygotominor {
                yy.yystatus = YYStatus::Accepted(root);
                yy.yystack.clear();
            } else {
                {
                    {
                        {
                            ::std::rt::begin_panic_fmt(
                                &::std::fmt::Arguments::new_v1(
                                    &["internal error: entered unreachable code: "],
                                    &match (&"unexpected root type",) {
                                        (arg0,) => [::std::fmt::ArgumentV1::new(
                                            arg0,
                                            ::std::fmt::Display::fmt,
                                        )],
                                    },
                                ),
                                &("examples/json.rs", 65u32, 1u32),
                            )
                        }
                    }
                };
            }
            Ok(())
        }
    }
}
fn main() {
    let args = std::env::args().skip(1);
    for arg in args {
        {
            ::std::io::_print(::std::fmt::Arguments::new_v1(
                &["arg: \'", "\'\n"],
                &match (&arg,) {
                    (arg0,) => [::std::fmt::ArgumentV1::new(arg0, ::std::fmt::Display::fmt)],
                },
            ));
        };
        match arg.parse() {
            Ok::<JObject, _>(j) => {
                ::std::io::_print(::std::fmt::Arguments::new_v1_formatted(
                    &["JSON: \'", "\'\n"],
                    &match (&j,) {
                        (arg0,) => [::std::fmt::ArgumentV1::new(arg0, ::std::fmt::Debug::fmt)],
                    },
                    &[::std::fmt::rt::v1::Argument {
                        position: ::std::fmt::rt::v1::Position::At(0usize),
                        format: ::std::fmt::rt::v1::FormatSpec {
                            fill: ' ',
                            align: ::std::fmt::rt::v1::Alignment::Unknown,
                            flags: 4u32,
                            precision: ::std::fmt::rt::v1::Count::Implied,
                            width: ::std::fmt::rt::v1::Count::Implied,
                        },
                    }],
                ));
            }
            Err(e) => {
                ::std::io::_print(::std::fmt::Arguments::new_v1_formatted(
                    &["Err: \'", "\'\n"],
                    &match (&e,) {
                        (arg0,) => [::std::fmt::ArgumentV1::new(arg0, ::std::fmt::Debug::fmt)],
                    },
                    &[::std::fmt::rt::v1::Argument {
                        position: ::std::fmt::rt::v1::Position::At(0usize),
                        format: ::std::fmt::rt::v1::FormatSpec {
                            fill: ' ',
                            align: ::std::fmt::rt::v1::Alignment::Unknown,
                            flags: 4u32,
                            precision: ::std::fmt::rt::v1::Count::Implied,
                            width: ::std::fmt::rt::v1::Count::Implied,
                        },
                    }],
                ));
            }
        }
    }
}