#![feature(prelude_import)]
#![no_std]
#[prelude_import]
use ::std::prelude::v1::*;
#[macro_use]
extern crate std as std;
use pomelo::pomelo;
mod parser {
#![allow(dead_code)]
#![allow(unreachable_code)]
#![allow(unused_variables)]
#![allow(non_snake_case)]
type Input = ();
type Error = ();
type ExtraArgument = ();
const YYNOCODE: i32 = 4i32;
const YYWILDCARD: i8 = 0;
type YYStack<T> = std::vec::Vec<T>;
const YYSTACKLIMIT: usize = 100usize;
enum YYMinorType {
YY0(()),
YY1(Input),
}
const YYNSTATE: i32 = 1;
const YYNRULE: i32 = 1;
const YYERRORSYMBOL: i32 = 0;
pub enum Token {}
#[inline]
fn token_value(t: Token) -> (i32, YYMinorType) {
match t {}
}
fn token_build(i: i32, yy: YYMinorType) -> Option<Token> {
match (i, yy) {
_ => None,
}
}
static YY_ACTION: [i32; 2usize] = [3, 1];
static YY_LOOKAHEAD: [i8; 2usize] = [2, 0];
const YY_SHIFT_USE_DFLT: i32 = -1i32;
const YY_SHIFT_COUNT: i32 = 0usize as i32;
const YY_SHIFT_MIN: i32 = 0i32;
const YY_SHIFT_MAX: i32 = 1i32;
static YY_SHIFT_OFST: [i8; 1usize] = [1];
const YY_REDUCE_USE_DFLT: i32 = -3i32;
const YY_REDUCE_COUNT: i32 = 0usize as i32;
const YY_REDUCE_MIN: i32 = -2i32;
const YY_REDUCE_MAX: i32 = 0i32;
static YY_REDUCE_OFST: [i8; 1usize] = [-2];
static YY_DEFAULT: [u8; 1usize] = [2];
static YY_FALLBACK: [i32; 0usize] = [];
static YY_RULE_INFO: [i8; 1usize] = [2];
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/one.rs", 3u32, 1u32),
),
}
}
fn is_normal(&self) -> bool {
match self {
YYStatus::Normal => true,
_ => false,
}
}
}
pub struct Parser {
error_count: u8,
yystack: YYStack<YYStackEntry>,
extra: (),
yystatus: YYStatus<Input>,
}
impl Parser {
pub fn new() -> Self {
Self::new_priv(())
}
pub fn end_of_input(mut self) -> Result<Input, Error> {
self.end_of_input_priv().map(|r| r.0)
}
pub fn parse(&mut self, token: Token) -> Result<(), Error> {
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<(Input, ()), Error> {
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<(), Error> {
if !yy.yystatus.is_normal() {
{
::std::rt::begin_panic(
"Cannot call parse after failure",
&("examples/one.rs", 3u32, 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<(), Error> {
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/one.rs", 3u32, 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/one.rs", 3u32, 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/one.rs", 3u32, 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/one.rs", 3u32, 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/one.rs", 3u32, 1u32),
)
}
};
if !(look_ahead != YYNOCODE) {
{
::std::rt::begin_panic(
"assertion failed: look_ahead != YYNOCODE",
&("examples/one.rs", 3u32, 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/one.rs", 3u32, 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/one.rs", 3u32, 1u32),
)
}
};
return YY_ACTION[i as usize] as i32;
}
fn yy_shift(
yy: &mut Parser,
new_state: i32,
yymajor: i32,
yyminor: YYMinorType,
) -> Result<(), Error> {
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) -> Error {
yy.yystack.clear();
let extra = &mut yy.extra;
{
Default::default()
}
}
fn yy_syntax_error_2(yy: &mut Parser, yymajor: i32, yyminor: YYMinorType) -> Result<(), Error> {
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, Error> {
let e = yy_syntax_error_2(yy, yymajor, yyminor)?;
Ok(YYMinorType::YY0(e))
}
fn yy_reduce(yy: &mut Parser, yyruleno: i32) -> Result<(), Error> {
let yygotominor: YYMinorType = match (yyruleno, &mut yy.extra) {
(0i32, extra) => {
let yyres: Input = match () {
() => {}
_ => ::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/one.rs", 3u32, 1u32),
),
};
YYMinorType::YY1(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/one.rs", 3u32, 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/one.rs", 3u32, 1u32),
)
}
};
if let YYMinorType::YY1(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/one.rs", 3u32, 1u32),
)
}
}
};
}
Ok(())
}
}
}
mod parser {
#![allow(dead_code)]
#![allow(unreachable_code)]
#![allow(unused_variables)]
#![allow(non_snake_case)]
type Input = ();
type Error = ();
type ExtraArgument = ();
const YYNOCODE: i32 = 4i32;
const YYWILDCARD: i8 = 0;
type YYStack<T> = std::vec::Vec<T>;
const YYSTACKLIMIT: usize = 100usize;
enum YYMinorType {
YY0(()),
YY1(Input),
}
const YYNSTATE: i32 = 1;
const YYNRULE: i32 = 1;
const YYERRORSYMBOL: i32 = 0;
pub enum Token {}
#[inline]
fn token_value(t: Token) -> (i32, YYMinorType) {
match t {}
}
fn token_build(i: i32, yy: YYMinorType) -> Option<Token> {
match (i, yy) {
_ => None,
}
}
static YY_ACTION: [i32; 2usize] = [3, 1];
static YY_LOOKAHEAD: [i8; 2usize] = [2, 0];
const YY_SHIFT_USE_DFLT: i32 = -1i32;
const YY_SHIFT_COUNT: i32 = 0usize as i32;
const YY_SHIFT_MIN: i32 = 0i32;
const YY_SHIFT_MAX: i32 = 1i32;
static YY_SHIFT_OFST: [i8; 1usize] = [1];
const YY_REDUCE_USE_DFLT: i32 = -3i32;
const YY_REDUCE_COUNT: i32 = 0usize as i32;
const YY_REDUCE_MIN: i32 = -2i32;
const YY_REDUCE_MAX: i32 = 0i32;
static YY_REDUCE_OFST: [i8; 1usize] = [-2];
static YY_DEFAULT: [u8; 1usize] = [2];
static YY_FALLBACK: [i32; 0usize] = [];
static YY_RULE_INFO: [i8; 1usize] = [2];
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/one.rs", 14u32, 1u32),
),
}
}
fn is_normal(&self) -> bool {
match self {
YYStatus::Normal => true,
_ => false,
}
}
}
pub struct Parser {
error_count: u8,
yystack: YYStack<YYStackEntry>,
extra: ExtraArgument,
yystatus: YYStatus<Input>,
}
impl Parser {
pub fn new(extra: ExtraArgument) -> Self {
Self::new_priv(extra)
}
pub fn end_of_input(mut self) -> Result<(Input, ExtraArgument), Error> {
self.end_of_input_priv()
}
pub fn into_extra(self) -> ExtraArgument {
self.extra
}
pub fn extra(&self) -> &ExtraArgument {
&self.extra
}
pub fn extra_mut(&mut self) -> &mut ExtraArgument {
&mut self.extra
}
pub fn parse(&mut self, token: Token) -> Result<(), Error> {
let (a, b) = token_value(token);
yy_parse_token(self, a, b)
}
fn new_priv(extra: ExtraArgument) -> 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<(Input, ExtraArgument), Error> {
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<(), Error> {
if !yy.yystatus.is_normal() {
{
::std::rt::begin_panic(
"Cannot call parse after failure",
&("examples/one.rs", 14u32, 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<(), Error> {
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/one.rs", 14u32, 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/one.rs", 14u32, 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/one.rs", 14u32, 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/one.rs", 14u32, 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/one.rs", 14u32, 1u32),
)
}
};
if !(look_ahead != YYNOCODE) {
{
::std::rt::begin_panic(
"assertion failed: look_ahead != YYNOCODE",
&("examples/one.rs", 14u32, 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/one.rs", 14u32, 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/one.rs", 14u32, 1u32),
)
}
};
return YY_ACTION[i as usize] as i32;
}
fn yy_shift(
yy: &mut Parser,
new_state: i32,
yymajor: i32,
yyminor: YYMinorType,
) -> Result<(), Error> {
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) -> Error {
yy.yystack.clear();
let extra = &mut yy.extra;
{
Default::default()
}
}
fn yy_syntax_error_2(yy: &mut Parser, yymajor: i32, yyminor: YYMinorType) -> Result<(), Error> {
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, Error> {
let e = yy_syntax_error_2(yy, yymajor, yyminor)?;
Ok(YYMinorType::YY0(e))
}
fn yy_reduce(yy: &mut Parser, yyruleno: i32) -> Result<(), Error> {
let yygotominor: YYMinorType = match (yyruleno, &mut yy.extra) {
(0i32, extra) => {
let yyres: Input = match () {
() => {}
_ => ::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/one.rs", 14u32, 1u32),
),
};
YYMinorType::YY1(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/one.rs", 14u32, 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/one.rs", 14u32, 1u32),
)
}
};
if let YYMinorType::YY1(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/one.rs", 14u32, 1u32),
)
}
}
};
}
Ok(())
}
}
}